Scale, From Qubits to Petabits

The scale of modern infrastructure can be measured in many ways — fields per second, requests per day, or the weight of the planet itself. The numbers below trace the outer edges of what systems handle today.

Twitter's GraphQL API serves 1.5 billion fields per second across 3,000 different data types. Netflix handles 1 billion GraphQL requests daily. Roblox's caching system absorbed 1 billion requests per second during its October 2021 outage recovery. During Cyber Monday, Stripe sustained more than 20,000 requests per second with a successful API rate above 99.9999%.

Serverless compute continues to grow. AWS Lambda now counts 1 million customers and processes 10 trillion monthly requests. But recursion has a cost: one development team spent $40,000 by calling Lambda functions recursively in an accidental loop.

On the security front, Google blocked a distributed denial-of-service attack peaking at 46 million requests per second — the largest on record. Vanuatu's government remained offline for 11 days following cyber-attacks. Apple's bug bounty program paid out just $48 million, a figure critics call inadequate.

Numbers of Note

  • 6 ronnagrams: the Earth's mass — a six followed by 27 zeros, under newly ratified metric prefixes.
  • 433: qubits in IBM's newest quantum computer, its most powerful to date.
  • 1.84 petabits per second: data transmitted using a single light source and optical chip — nearly twice global internet traffic in the same period.
  • 57 GB: daily data downlinked from the James Webb Space Telescope.
  • 2 trillion: estimated galaxies in the observable universe.
  • 1 TB: Starlink's new monthly data cap, which also lowers advertised speeds.
  • $72.6 billion: annual flash chip revenue.
  • 0: memory safety vulnerabilities found in Android's Rust code as of version 13.
  • 80%: latency reduction Couchbase reports when deploying at the edge.
  • 25%: share of cloud migrations classified as lift-and-shift, down from prior years.
  • 10%: share of John Deere revenue expected from subscription fees by 2030.
  • 8 billion: the human population as of November 15, 2022.

From the Archives

Two historical photographs bracketing more than six decades of engineering got attention: an engineer wiring an early IBM computer in 1958, and an engineer wiring an early IBM quantum computer in 2021. The technique looks similar — the technology does not. A tweet comparing the two drew wide engagement. A similar pairing between an early computing pioneer and a quantum machine highlighted how far the field has come.

Separately, an updated edition of Explain the Cloud Like I'm 10 is available, covering AWS, Azure, GCP, and Kubernetes. The book now includes twice the material of the original and holds more than 480 five-star ratings.

The Cloud Bill Reality Check

This week's discourse on scalability is dominated by the economics of cloud computing. A recurring theme is the tension between leveraging managed services and the unpredictable costs that come with them. One poignant example highlights the difficulty of forecasting egress fees: on CloudFront, 60TB of data transfer can cost anywhere from $4,761.60 to $6,348.80, depending entirely on the geographic location of the users making the requests—a variable that is practically impossible to predict in advance.

The choice between building on public cloud versus owning infrastructure is a frequent point of contention. One perspective notes that by managing its own data centers, Roblox has been able to control costs and manage latency more effectively than it could with public cloud providers, whose data centers are not necessarily close to its global player base. Similarly, a Stanford course found that the quarterly cost of cloud VMs and bandwidth was enough to cover several years of on-premises infrastructure. Others report more favorable experiences with serverless, citing "fat Lambda" functions as a fraction of the cost of the cheapest always-on AWS hardware, provided the workload doesn't require a large, dedicated instance.

The Serverless Identity Crisis

The definition and value proposition of "serverless" continue to be a source of debate. A key critique is that the industry is drifting toward a model that removes burdens from developers, rather than one that eliminates concerns for the business as a whole—two goals that are often not well-aligned. While some teams are moving away from serverless due to operational complexity, CI/CD challenges, and observability, others note that companies like LEGO and PostNL have successfully adopted the model at scale, suggesting the technology itself is not inherently problematic.

Regarding cost, one user reports saving significantly by moving from Amazon Aurora Serverless to PlanetScale for a development environment, getting a full suite of non-production databases for less than the cost of a single Aurora instance. However, a counterpoint argues that managed Kubernetes is a viable path for those who need more control, despite its own set of challenges. The discourse also touches on the inverse relationship between load and performance in serverless, where increased requests per second can actually lead to lower latency.

Hardware, Time, and Databases

On the hardware front, AMD's Genoa server CPU is reported to deliver a score of over 1500 in SPECInt_Rate 2017, compared to 602 for Intel's top-tier Ice Lake chip. Analysis also suggests that the era of easy scaling via Dennard scaling and Moore's Law is over, forcing a significant shift in chip design and manufacturing dynamics. The role of infrastructure components is also evolving, with DPUs being pitched as a way to bring networking, security, and storage functions closer to workloads without burdening the main server CPU.

Precise timekeeping is another subject of interest, particularly for distributed databases. A nuanced explanation describes how "snapshot reads" rely on a monotonic clock. More accurate timestamps can reduce the delay required to account for worst-case clock error, which in turn increases server capacity. Meta's experiments support this, showing that its early Precision Time Protocol (PTP) implementation offered a roughly 100x performance improvement over its state-of-the-art NTP implementation. In the data store arena, one thread details a move away from CockroachDB to PlanetScale, which the user says was significantly cheaper and less of a headache than running RDS, having previously left Aurora Serverless for similar reasons.

Engineering Culture and Complexity

Several observations touch on the intersection of engineering practices and organizational culture. The success of '@swardley's' portfolio is not included in the source text. One post reflects that the overly complex tech stacks built by startups in the 2010s were partly a result of hiring only from Google and Facebook, a practice with both pros and cons. Another argues that Twitter's failure was a product and leadership problem, not a result of its engineering culture being insufficiently high-performing.

There's also a strong sentiment against needless complexity. A critique of Kubernetes and microservices suggests that many startups are "cargo culting" the architectures of massive companies that had no other choice but to scale out. A simpler approach is often better. This extends to tooling; the author of the BoltDB library admits its design was a poor fit for production and wasn't intended for it. Similarly, a humorous take describes a datacenter CEO who unplugged servers deemed as "not doing anything," without warning, to save on power.

AI and the Next Frontier

The potential of large language models is a dominant topic. One quote notes that these models, with parameter counts roughly 1/1000 of the brain's synapses, already contain more information than a single human can know, suggesting that human-level AGI might initially run in a smaller "box" rather than a massive data center. Observations on tools are also noteworthy: one user says ChatGPT can generate hundreds of lines of Python for multipart uploads to S3, and even knows how to edit its code. A combining approach is highlighted, where LLMs express reasoning as a program that a symbolic solver then executes.

Demis Hassabis postulates that AI might be the perfect description language for biology, as end-to-end systems can learn constraints better than human designers can specify them. In a more basic context, a Rust Lambda function handling millions of requests per day does two GetItem and one BatchGetItem calls to DynamoDB in 10-15ms; caching the result in the execution context brings that down to under 3ms.

Snap's AWS Architecture

Snap has published details on how it handles 300 million daily active users and 5 billion+ snaps per day at roughly 10 million QPS. The flow: a client sends a request to a gateway service running in EKS, which talks to a media delivery service that pushes the snap to CloudFront and S3 so it is closer to the recipient. Once the client persists the media, it notifies core orchestration services, which check the friend graph for permission before persisting metadata into SnapDB — a database using DynamoDB as its backend that handles transactions, TTL, ephemeral data and state synchronization.

Receiving is latency-sensitive: the orchestration layer looks up a persistent connection per user in Elasticache, finds the hosting server, and pushes the message through it; the media ID is then used to fetch from CloudFront. Snap reports that moving to this architecture reduced P50 latency by 24%, and runs 900+ EKS clusters with 1,000+ instances per cluster. It stores 400 TB in DynamoDB, where nightly scans process 2 billion rows per minute for friend suggestions and ephemeral data deletion. Auto-scaling and Graviton instance type optimization keep compute costs down.

The Economics of Moving Twitter to the Cloud

As Twitter undergoes a natural experiment in how deeply you can cut a software organization, former employees are pushing back on the idea that the company could simply move to AWS. Numbers from someone who was inside the effort: at a 60% AWS discount, running Twitter would require on the order of 500,000 m6gd.12xlarge instances at roughly $300MM per month, before bandwidth — another $10MM monthly even at a 90% discount, plus S3 costs. Realistically, cloud experiments were so resource-intensive that one engineer accidentally saturated the network for an entire region while running a 1,000-node Presto cluster; such clusters required warming up incrementally at 100, 250, 500 and 750 nodes. And no provider will hand you 50,000 EC2 instances instantly just because you can provision 20.

What motivated the cloud work was primarily latency reduction. Efforts in 2019–2021 focused on cutting tail latency on requests and optimizing a 400 Gbps datacenter backbone. A separate account of the internal environment paints a messier picture: config-management write access was locked when the last authorized person left, the identity management system needed to restore access was down, and a pile of core systems — Kerberos, LDAP, Puppet, plus base configs for database and storage clusters — run on bare metal managed by Puppet, entirely off the diagrams circulating publicly.

Service internals aside, there is also the question of how microservice-y Twitter really is. One engineer contrasts the popular mental model with reality: a cold Google search might fire >1000 RPCs, but that flurry happens inside the datacenter after a few client API calls. On Bing in 2014, a single query translated to ~20 requests from browser to FrontDoor, then 2000+ internal RPCs. Musk's math about India — 20s load times from 1200 RPC calls — is off by orders of magnitude: at 250ms Bangalore-to-SF RTT, 1200 serial calls would take 5 minutes; 20 seconds implies a maximum of 80 sequential calls, with the real number likely 5–10, the rest happening in-datacenter.

Others point out that a full migration would be a multi-year project. One former Vine engineer notes Vine ran on AWS while a Twitter property at roughly $12M yearly for 30 million MAU; Twitter's 450 million users would scale that up dramatically, with a migration cost estimated at ~1000 man-years. Operations realities matter too: a single filled hard drive on a hosed box can cascade across fault-tolerant systems, and somebody has to find the box and figure out what's filling it. There is also a counterpoint on how much the platform has improved: over five years, Twitter migrated almost every app API into a unified GraphQL interface, cutting production change timelines from weeks to hours. Every new feature for two years — Twitter Blue, Spaces, tweet edit, Birdwatch — shipped on that platform, which serves 1.5 billion GraphQL fields per second across 3000 data types, with over 1000 changes from 300+ developers in a single calendar year.

Inside the 73-Hour Roblox Outage

Roblox published a detailed incident report on its October 2021 outage, caused by new features under load. The company runs its own infrastructure — 18,000+ servers and 170,000 containers — with HashiCorp's Nomad, Consul and Vault managing orchestration and service discovery. The failure traced to Consul KV writes getting blocked under contention. On October 27th, Roblox enabled a streaming feature on traffic-routing backend services and increased those nodes by 50% for expected end-of-year load. The streaming implementation used fewer Go channel concurrency controls than long polling; under both high read and high write load, contention on a single Go channel caused blocking during writes.

Once streaming was disabled, P50 Consul KV write latency dropped to 300ms. Recovery required restarting an unhealthy caching system and ratcheting player access back up in roughly 10% increments via DNS steering, checking database load and cache performance at each step. Roblox acknowledges that running all backend services on one Consul cluster left it exposed; a second geographically distinct datacenter is being built out, with moves toward multiple availability zones underway.

Leaving the Cloud, and the Serverless Spectrum

37signals (Basecamp and HEY) announced it is leaving the cloud, arguing that renting computers is a bad deal for medium-sized companies with stable growth. Specifics: HEY spends over half a million dollars per year on Amazon RDS and Elasticsearch — enough to buy extremely beefy servers outright. Total cloud budget is around $3 million a year. The promised complexity savings never materialized; the company found it wasn't using fewer operations people. They won't rack hardware themselves — datacenters offer white-glove service where staff unwrap, rack, and cable machines — and the complexity is elsewhere anyway. They'll keep using S3 for a while. The editorial take: this is less a principled stand than a reasonable decision for a company with predictable growth, an expert ops staff, and an architecture that doesn't look particularly cloud-native. Others without those DBAs and ops people will reasonably make different choices.

One piece in the discussion argues against thinking of "serverless" as a spectrum: a service is serverless if you can use it via API without managing the underlying architecture. If you're paying a $700 minimum for fixed resources (AWS OpenSearch), that's not serverless. FaaS deserves its own label since container-based HTTP serverless options like Cloud Run and App Runner aren't function-oriented.

PlanetScale Boost and the NoSQL Advantage

PlanetScale announced Boost, a partial materialization engine running alongside its database that improves SQL query performance and throughput by up to 1,000×. The design inverts the traditional model: instead of planning how to fetch data on every read, it plans how to process data on every write, pushing data on writes so reads become nearly free. Queries can still miss, but misses are resolved more intelligently. Commentators are enthusiastic about dynamic, partially-stateful data-flow for incremental materialized view maintenance becoming more widespread. The NoSQL counterpoint: with a correct data model, every NoSQL query is O(log(n)), which blows past even simple RDBMS joins. One engineer claims most of Amazon's retail infrastructure runs on NoSQL design patterns his team invented. The relational response: materialized views should let relational databases compete; PlanetScale Boost is that bet.

Instacart details one migration from Postgres to DynamoDB: its primary store, Postgres, hit the ceiling when specific use cases outgrew the largest EC2 instance size. Push notifications projected 8× growth in daily sends. Rather than fight Postgres scaling, Instacart adopted DynamoDB, wrapping an open-source library (Dynamoid) that exposed an ActiveRecord-like interface. The result: not only solved scaling, but cut costs nearly in half. In six months they grew from 1 to 20+ tables supporting 5–10 features. Their guidance: use Dynamo from the start for new standalone workloads that fit it; migrating existing Postgres tables is harder, especially heavy workloads and denormalization challenges.

Bare-Metal to Serverless: Cost Lessons

Prerender cut annual server costs from $1M to $200K by leaving AWS. Handling 70,000+ pages per minute and storing ~560 million pages, the hidden cost driver was traffic: AWS storage is reasonably priced and free to upload, but egress costs ran $30k–$50k per month. By migrating cached-page traffic to internal servers, then shard-by-shard from RDS to its own Cassandra cluster, monthly fees dropped 80% versus the initial 40% projection. Stopping S3 writes alone saved $200/day in API costs.

Cumulus took a different route within AWS, cutting monthly bills 71% while increasing resilience after a 400% cost spike. Their customers have bursty usage; the old monolithic system required provisioning for peak. Moving to serverless microservices, DynamoDB tables instead of relational storage, granular IAM policies replacing shared-secret auth, AWS Backup for point-in-time recovery, removing AppSync cache, and reducing verbose logging all contributed. Another report shows significant Lambda savings with zero code changes: switching runtime architecture from x86_64 to ARM64 (AWS charges 25% less, no visible performance change), dropping parallelizationFactor from 3 to 2, raising maximumBatchingWindow to 3 seconds (adding only double-digit-millisecond delay), and observing that higher memory configurations bring little benefit and high risk.

Cloudflare's Edge Platform Bets

Cloudflare used Developer Week to argue it should be your serverless cloud, positioning itself as an edge platform where code runs at every point of presence rather than in a single datacenter — a harder problem, which it brands the Supercloud. Components include Durable Objects (an Actor-model take), Queues, R2 object storage (cheaper than S3, no egress fees), Workers, Cache Reserve (a CDN with lower egress fees — closed beta showed 8,000+ sustained PUTs/sec, 3,000+ GETs/sec, ~600 TB cached for large customers), Cloudflare Logs, D1 (a relational database not yet usable), and Pages + Functions for static hosting plus server-side JavaScript. One founder reports EstiiHQ is fully hosted on Pages/Workers/KV/DurableObjects and hasn't exceeded the $5/month Pro tier.

Cloudflare's Pingora Proxy

Cloudflare also detailed Pingora, the Rust-based HTTP proxy serving over 1 trillion requests daily, replacing its previous proxy infrastructure with a third of the CPU and memory. Rust was chosen for C-level performance with memory safety. The architecture is multithreaded (not multiprocess) with work stealing, sharing connection pools across threads to improve connection reuse. Results: median TTFB down 5ms, 95th percentile down 80ms; one major customer's connection reuse ratio went from 87.1% to 99.92%, reducing new connections to origins 160×. Pingora makes only a third as many new connections per second, consumes ~70% less CPU and 67% less memory, and crashes are so rare that when one happens, engineers usually find an unrelated issue.

Scaling and Performance Case Studies

Tinder built the TAG API Gateway to replace multiple third-party gateways that each team had chosen independently, which became unmanageable. TAG is a JVM framework on Spring Cloud Gateway where teams create their own gateway instance by writing configuration. It centralizes external APIs, enforces authorization and security, and provides pre-built filters for weighted routing, request/response transformations, and HTTP-to-gRPC conversion. With 500+ microservices behind a service mesh, TAG handles 190 countries of traffic and is used by other Match Group brands including Hinge, OkCupid, and PlentyOfFish.

Walmart's inventory reservations API shows the standard optimization toolkit for write-heavy workloads: scatter-gather requests with sticky sessions so each database partition is always processed by the same instance; in-memory concurrency with an actor pattern and mailbox restricting each partition to a single thread, aiding batch processing; and in-memory snapshot state caching to cut reads.

Netflix's Titus Gateway hit the vertical scaling limit of its read-only API and went horizontal with a consistent caching mechanism for a singleton-leader-elected source of truth where data fits in memory. Tail latencies improved with minor median latency sacrifice at low traffic, and the gateway processing layer can now scale out without API client changes. In a separate effort, Netflix used performance monitoring counters to find a bottleneck in the JVM's native code during a migration to m5.12xl instances — throughput increased only ~25% with 50% worse latency at the same CPU target. Patching the JVM delivered better than threefold throughput for the workload; hardware counter introspection proved the only way to find that class of issue.

Several Datacenter Transport Takes

A paper argues TCP's problems are too fundamental to fix and proposes Homa, a new datacenter transport protocol. Others point out we could do better than TCP/IP in controlled environments. Amazon has SRD (scalable reliable datagram), an Ethernet-based transport on dedicated Nitro hardware that focuses on performance with multi-pathing and microsecond-level retries — a datacenter is not the internet, so reliability can be traded. SRD reduces EBS tail latency, which is what matters since average latency is not the constraint. Also referenced: Google's Aquila unified low-latency fabric, CliqueMap RMA-based distributed caching, and Snap, a microkernel approach to host networking.

Cost-Efficiency Examples

Shopify fixed a $1 million BigQuery query. The 75 GB billed per query ran 194,400,000 GB monthly at ~$949K under on-demand pricing. Clustering the dataset on the two feature columns in the WHERE clause cut billed data to 508.1 MB per query — 150× less, bringing the monthly cost to ~$1,370.

Honeycomb's serverless experience: Lambda median startup time of 50ms (hot and cold similar), 90% of responses within 2.5 seconds; 3–4× more expensive than EC2 but far more infrequent. Guidance: use Lambda for urgent real-time bulk workloads, keep data accessible in the cloud with parallel workloads, and tune and observe before scaling out — then measure carefully, especially cost. Also, the storage engine notes: lock-free B+ tree indexing with log-structured storage, local SSD (not remote-attached), batching to cut network/disk IO, custom allocators for request patterns, and a custom async coroutine scheduler.

Intel finalized "Intel on Demand," a pay-as-you-go mechanism for CPU features via weekly, monthly, or yearly subscription. Azure Cosmos DB reports a customer with 100 million requests per second over petabytes of storage across 41 regions, and notes it never spans processes across NUMA nodes, keeping memory access latency predictable on cache misses.

AI Coding Assistants, Mark II

Kite is shutting down despite building what it calls the most advanced AI developer assistant at the time, because the state of the art in ML on code isn't good enough for the 10× improvement required to break through. GitHub Copilot shows promise but models still don't understand code structure like non-local context. A separate experiment found an AI proactively identifying a real bug: asked to rank token probabilities in existing code, the model flagged a spot where an event listener removal during dispatch returned instead of continuing — suggesting continue where the human wrote return. A commenter's concerns: if code has so little entropy that an AI can reliably predict the next token, that's evidence the developer is operating at too low a level of abstraction; tools that help in today's languages prompt the question of what a future language abstracting away boilerplate would look like.

Serverless 2.0 and Other Notes

A talk asks what Serverless 2.0 should be: all services serverless with scale-to-zero, no instance sizes, better caching/orchestration/HPC, and fixes for pain points — DynamoDB is easy to adopt but hard to change for new access patterns; deployments never work first time (permissions and wiring are wrong), so we need validation that a function will run; deployments need to be faster; infrastructure-as-code works for functions but not wiring, networking, and security. Microsoft is investing in owning the developer environment — cloud editor, VSCode, GitHub, NPM, GitHub Actions, and Copilot writing half the code.

Roblox aside, community links cover P99 Conf and ServerlessDays NY videos, NimConf 2022, AWS re:Invent 2022 recordings, and assorted writeups including scaling PostgresML to one million predictions per second on commodity hardware, and scaling Mastodon — which the author calls impossible, though centralized virtual layers on top of the fediverse remain a likely outcome.

An incident report on scaling the JWST image pipeline reminds us the raw telescope data is uneven; thousands of person-hours went into characterizing sensors, noise and electronics so images can be processed automatically with high precision — calibration maps compensate for per-pixel variations, while sub-pixel exposure alignment and point-spread-function knowledge improve the final output.

Architecture to Watch

Netflix's Titus caching generalizes: any singleton-leader-elected component whose data fits in memory with low latency can apply the consistent-caching pattern. On the database front, the JVM giveth and taketh away; for new noSQL, @stefanwild echoes Instacart's guidance: use DynamoDB from the start for standalone workloads. For cross-system event design, the consensus favors fat events — do the work up front, avoid rehydrating on the read side; coupling isn't the issue since all code stays in sync anyway, though decisions change when events cross system boundaries. Meanwhile, zero trust means removing implicit trust inside the network — not trusting layer 3 or 4 access but logging in at the application layer with least privilege and HTTPS everywhere, per the OMB memo guidance.

Open-Source Roundup

A collection of notable open-source projects and tools has emerged recently, offering everything from AI code generation to embedded databases and serverless backend solutions.

  • Kite has open-sourced much of its codebase for AI-powered code generation.
  • Dark aims to simplify serverless backend development by letting developers focus solely on code, eliminating the need to manage infrastructure, frameworks, or deployment.
  • gluesql provides a SQL database library written in Rust.
  • FlashDB is an ultra-lightweight embedded database supporting both key-value and time-series data models.
  • Supabase offers itself as an open-source Firebase alternative, bundling a Postgres database with Authentication, instant APIs, Edge Functions, Realtime subscriptions, and Storage.
  • The Hasura GraphQL Engine now supports streaming subscriptions on Postgres, claiming to handle 1M concurrent GraphQL clients streaming from 10,000 channels, ingesting 1M events per minute on a single Postgres RDS instance.
  • TinyBase presents a new approach to structuring local application data.
  • SurrealDB positions itself as an end-to-end cloud-native database for a wide range of application types, including web, mobile, serverless, and jamstack.
  • EdgeDB introduces a database designed to extend the relational model and resolve the object-relational impedance mismatch.

From the Research Front

A range of recent papers and technical reports highlight advances in AI, system security, and large-scale infrastructure design.

AI and Machine Learning Advancements

  • A Science paper details Cicero, a system that combines language models with strategic reasoning to achieve human-level play in Diplomacy. Across 40 anonymous online games, the AI scored more than double the average human player's score and ranked in the top 10% of participants who played more than one game.
  • Meta's Monolith system is a real-time recommendation engine featuring a collisionless embedding table, expirable embeddings, and frequency filtering to reduce memory usage. The paper describes a production-ready architecture with high fault tolerance, arguing that system reliability can be traded for real-time learning.
  • Meta's MultiRay project is optimizing efficiency for large-scale AI models, reportedly running at 20 million queries per second—totaling 800 billion per day.
  • A paper on abuse and fraud detection in streaming services outlines a framework that models user streaming behavior to identify anomalous and suspicious incidents and scale investigative efforts.
  • Researchers have presented the first end-to-end locomotion system enabling a medium-sized quadruped robot to traverse challenging terrain like stairs, curbs, and gaps using only a single front-facing depth camera.

Infrastructure and Systems Design

  • A paper on scalable algorithm simplification using quantum AND logic describes a resource-efficient construction that reduces compilation overhead for quantum circuits.
  • The AWS Nitro System security whitepaper details the architecture's design, which by design eliminates the possibility of administrator access to EC2 servers. It covers the passive communications design and change management process, as well as mitigations against potential side-channel issues.
  • A study on fail-slow faults at scale demonstrates that all hardware types—disk, SSD, CPU, memory, and network components—can exhibit performance faults. The research found faults can morph between forms, lead to cascading root causes, and present varying symptoms.
  • A paper titled "A World Wide View of Browsing the World Wide Web" reveals that beyond a small set of global sites, most websites are country-specific. Of sites in the top 1K for at least one country, over half don't rank in the top 10K for any other country.
  • Meta's Owl system demonstrates that centralizing the control plane for peer-to-peer distribution doesn't hinder scalability. It distributes over 800 petabytes daily to millions of clients, improving download speeds by a factor of 2–3 over BitTorrent and prior static distributions, while supporting 106 use cases with 55 distinct policies.