Trade-offs & Decisions

Advantages: simple mental model; the server can inspect every byte as it arrives, which can matter for validation or content scanning done inline. Disadvantages: consumes app-tier bandwidth and connections for pure data transfer; couples upload scaling to business-logic-server scaling.

Advantages: app servers stay lightweight and only issue credentials; object storage is purpose-built for this bandwidth; upload and application scaling become independent. Disadvantages: requires a short-lived, scoped upload credential and more orchestration; any inline inspection/validation the app tier would have done in-path now has to happen at a different point (e.g. at finalize, or asynchronously after).

Advantages: no job-tracking infrastructure needed; simpler mental model. Disadvantages: upload latency scales with video length/complexity; CPU-bound transcoding blocks an otherwise I/O-bound service; one slow job can starve unrelated requests.

Advantages: the upload path acknowledges as soon as the upload is accepted/finalized — not once the video is fully ready; processing workers scale independently; retryable and trackable. Disadvantages: video isn't immediately playable in all qualities; requires job-status tracking and a creator-facing 'processing' state.

Advantages: one system to operate; can be a reasonable choice for small media blobs in a small prototype. Disadvantages: relational databases are not built for multi-gigabyte binary blobs at real video-platform scale; every read/write competes with transactional metadata traffic; far more expensive per gigabyte.

Advantages: durable via replication; highly scalable; dramatically cheaper per gigabyte; purpose-built for large binary objects. Disadvantages: no relational queries — the database still needs pointers/metadata to make objects discoverable.

Advantages: simplest possible setup, no caching layer to reason about. Disadvantages: origin bandwidth becomes the bottleneck under real viewer volume; high latency for viewers far from origin; no resilience to a video suddenly going viral.

Advantages: popular content served from edges near viewers; massively reduced origin traffic; lower latency; far higher aggregate throughput. Disadvantages: cache misses still reach further upstream; cache invalidation and freshness need to be reasoned about; additional infrastructure and cost.

A CDN alone still concentrates every edge's misses onto origin. Adding an origin shield/tiered cache changes what 'CDN failure' means for origin protection — see Direct Origin vs. Origin Shield below.

Advantages: simpler to produce (no segmentation step). Disadvantages: poor buffering behavior and clumsy seeking compared to segmented delivery, and it can't support adaptive bitrate switching mid-playback.

Advantages: efficient buffering, fast seeking to any timestamp, partial retrieval, resilient recovery from a dropped segment, and it enables adaptive bitrate switching between segments. Disadvantages: more files to produce, store, and cache-key; slightly more complex manifest/playlist logic.

Advantages: simplest player logic. Disadvantages: stalls playback on weak/variable networks; wastes bandwidth on strong ones; can't respond to changing conditions mid-playback.

Advantages: the client picks a sustainable quality per segment based on real-time bandwidth and buffer measurements, smoothing playback across a wide range of network conditions. Disadvantages: requires the multi-resolution rendition ladder and aligned segmentation to already exist; more complex client-side logic.

Advantages: predictable capacity and cost. Disadvantages: a burst of uploads creates an unbounded backlog with no automatic relief; over-provisioning for peak load wastes money the rest of the time.

Advantages: worker count tracks demand automatically; backlog drains without manual intervention; cost scales with actual load. Disadvantages: autoscaling has real startup delay (new capacity isn't instantly available); queue depth alone can be a misleading signal (see Architecture Deep Dive -> Processing Backpressure); worker capacity can be constrained by CPU/GPU/codec-specific hardware rather than scaling freely; a backlog can still grow even at maximum practical worker count during a genuine capacity-exceeding spike.

Advantages: no additional system to operate; relational databases can support full-text search reasonably well at moderate scale. Disadvantages: ranking sophistication, query-pattern flexibility, and scale/isolation from transactional traffic all become harder as requirements grow.

Advantages: purpose-built for text search and relevance ranking; isolates search load entirely from metadata writes/reads. Disadvantages: the index lags metadata by an indexing delay, and it's another system to keep in sync and operate.

Advantages: lower lag between a view happening and the count reflecting it — closer to a direct update. Disadvantages: severe write contention on a single row for any popular video; under concurrency and failure, 'exactly current' is a stronger claim than a synchronous counter actually delivers once retries, failures, and concurrent writers are accounted for.

Advantages: batches many increments into a handful of writes; scales independently of raw view rate; naturally absorbs bursts. Disadvantages: the displayed count lags reality by an aggregation window; requires bounded, identity-based de-duplication of view events, which suppresses duplicates within its retained window without being a guarantee of exact lifetime counts.

Advantages: simpler to operate; CDN already solves most delivery-latency pain for cached content. Disadvantages: origin region failure risks a global outage for anything not already cached; distant creators pay real upload/processing latency and cross-region transfer cost.

Advantages: origin availability and disaster recovery; upload/processing locality; independent regional scaling and failure isolation. Disadvantages: requires an explicit metadata write-ownership and replication model (see Architecture Deep Dive -> Multi-Region Ownership) and fencing before failover — without these, multi-region can introduce conflicting-write risk rather than removing risk; meaningfully higher operational complexity.

Advantages: simplest possible job model; nothing to orchestrate between stages. Disadvantages: a failure anywhere (one bad rendition, a thumbnail bug) looks the same as total failure; no parallelism between independent stages; retrying means redoing everything, including work that already succeeded.

Advantages: independent stages (and often independent renditions) can run in parallel; partial failure is precisely diagnosable and partially retryable; per-stage state gives real visibility into where a video actually is in processing. Disadvantages: more orchestration complexity; needs a scheduler/workflow layer capable of expressing dependencies between stages.

Advantages: every rendition is ready the moment processing completes; no first-viewer latency penalty; simpler playback-time logic (nothing to trigger on demand). Disadvantages: pays full compute and storage cost for every rendition even if some are rarely or never requested — a real cost for the long tail of content.

Advantages: avoids compute/storage cost for renditions that turn out to be unpopular. Disadvantages: the first viewer requesting a not-yet-generated rendition pays real added latency; adds real implementation complexity (a generation-on-miss path, coordination with the safe-publication boundary, and cache-ability of a rendition that didn't exist a moment ago).

Advantages: simpler pipeline, less compute/storage per video, fewer compatibility edge cases to test. Disadvantages: risks poor compatibility or poor efficiency on some portion of the device/browser population, depending which single codec is chosen.

Advantages: can serve each device population its best-supported, most efficient option. Disadvantages: multiplies compute and storage cost per additional codec; more combinations to validate and keep aligned in the rendition ladder.

Advantages: no extra storage held for superseded versions. Disadvantages: unsafe under a long-lived CDN cache key — a viewer or edge that already cached the old bytes under that key can end up with an inconsistent view, and there's no clean way to guarantee every reader has moved to the new bytes atomically.

Advantages: safe under long-TTL CDN caching, since a version's bytes genuinely never change once published; supports the safe-publication and blue/green-style reprocessing patterns described in Architecture Deep Dive; makes rollback to a prior known-good version simple. Disadvantages: superseded versions need an explicit garbage-collection policy so storage doesn't grow unbounded.

Advantages: one fewer layer to operate. Disadvantages: a viral or newly-published video creates independent cold misses at every edge worldwide, each hitting origin directly — origin sees miss amplification proportional to the number of edges, not the number of distinct objects.

Advantages: collapses cross-edge miss fan-in — many edges' misses resolve against the shield instead of each independently reaching origin; meaningfully reduces peak origin load during a cold, suddenly-popular object. Disadvantages: another caching layer to operate and reason about; adds a hop for a genuine shield-miss.

Advantages: familiar, simple caching model. Disadvantages: requires actively invalidating or waiting out the TTL whenever the underlying bytes change — awkward for content that's supposed to be genuinely immutable, and risky if invalidation is missed (see Failure & Scale -> Stale Manifest).

Advantages: because the key itself encodes the version, there's never a 'stale vs fresh' ambiguity for a given key — old versions simply have different keys, and the object behind any given key genuinely never changes. This removes the need for invalidation entirely for that object, in favor of very long TTLs. Disadvantages: superseded-version objects need their own garbage-collection story (see Storage Lifecycle) since old keys can't just be 'refreshed' — they're abandoned, not updated.

Advantages: simplest possible CDN/origin configuration; fine for genuinely public content. Disadvantages: cannot enforce any access restriction — anyone with a URL can retrieve the content indefinitely, regardless of what the metadata layer says about visibility.

Advantages: the delivery layer itself enforces a short-lived, scoped credential, so the CDN/origin can't be used to bypass the authorization decision made by the metadata/auth service. Disadvantages: added issuance/validation complexity; cache-key design must account for the credential without fragmenting the cache (see Architecture Deep Dive -> CDN Cache Key).

Advantages: defensible, auditable number — necessary wherever the count has financial or contractual consequences (this module treats billing/financial counters as a stricter, separate concern, out of scope). Disadvantages: requires durable, globally-scoped deduplication and much stronger consistency guarantees than a simple bounded dedupe window provides — meaningfully more engineering investment.

Advantages: bounded, identity-based dedupe within an aggregation window is simple, cheap, and good enough for a popularity signal users glance at. Disadvantages: does not guarantee an exact lifetime count — a sufficiently delayed duplicate or a dedupe-state loss can still cause a small discrepancy.

Advantages: uniformly fast regional access and uniform disaster-recovery posture for every video. Disadvantages: multiplies storage and cross-region transfer cost by the number of regions, for content that may never actually be requested outside its home region.

Advantages: replication follows durability requirements, data-residency constraints, actual popularity, and cost — long-tail content stays near its origin region, popular content earns broader replication. Disadvantages: a cache miss for content that isn't replicated to the requesting region has to reach back to a region that does have it, which can mean higher latency or, in a regional-failure scenario, real unavailability if the only copy is in the failed region.

Advantages: simplest operational model — one cache-key scheme, one set of provider-specific behaviors to reason about. Disadvantages: a provider-wide CDN outage removes the platform's entire edge-caching layer at once (see Failure & Scale -> CDN Provider Outage).

Advantages: can route around a single provider's outage or regional weak spot; can optimize cost/performance per region or per provider's strengths. Disadvantages: meaningfully higher operational complexity — cache-key behavior, invalidation, and origin-protection controls all need to be consistent (or deliberately reconciled) across providers; genuinely harder to reason about and test.