The problem and the scale
Metaserver is the Python server that has run Dropbox's web and API traffic since 2007. By the time the Atlas team wrote about it in March 2021, Dropbox served more than 700 million registered users and at least 300,000 requests per second. The server monorepo held more than 3 million lines of Python in that monolith, and about half of all commits to the server repository touched Metaserver. It was pushed to production every day, for every user, as one unit.
The size alone was not the problem. Plenty of companies run large monoliths without pain. The problem was that every endpoint shared one fate in production. A bug in code owned by one team could force a rollback of the whole cluster, which meant everyone else's change of the day went out with it. Code sharing was implicit, so import cycles grew between features that had no business knowing about each other. And the serving framework itself had aged: it only supported HTTP/1.0, and metrics and tracing had to be rebuilt by hand instead of coming from a standard stack.
So Dropbox had three distinct failures stacked on top of each other: a tangled code graph, a shared release train, and infrastructure debt in the serving layer. The interesting part of the story is that they solved them with three different mechanisms, and refused the one tool that claims to solve all three at once.
The architecture before, and the attempt that broke
The first answer was the textbook one: service-oriented architecture. The effort ran for more than a year and a half. Its first milestone worked well: core capabilities like identity management were extracted behind RPC interfaces. That part is the classic win of SOA, because identity is a shared, stable, high-value capability with a clear contract.
The second milestone was to break Metaserver into services owned by product teams, and that is where it stopped working. The article is blunt about why: small, self-contained functionality "doesn't need independently operated services." Each new service brought its own capacity planning, alerting and multihoming. For a team owning a handful of endpoints, that operational tax was larger than the benefit of independence. The reliability problems that showed up were the predictable result of asking dozens of product teams to become operators.
This is the crux. Microservices bundle two things that are not the same: independent deployment and independent operation. Dropbox wanted the first and found the second too expensive at the granularity of a product feature.
Mechanism 1: Atlasservlets, an ownership boundary enforced by the build
Atlas groups routes into Atlasservlets: logical, atomic groupings of endpoints that belong together. At the time of writing there were more than 200 Atlasservlets covering more than 5,000 routes. Each one lives in a private directory that only its owning team can modify, and Bazel visibility rules stop other code from importing it.
That last detail does most of the architectural work. An ownership boundary written in a wiki decays. A boundary enforced by the build system fails a pull request the moment someone reaches across it. The team says the most strategically effective part of the whole project was breaking import cycles and reorganizing Metaserver into feature-based directories, which is code work, not infrastructure work.
What it looks like in practice is ordinary Bazel. The snippet below is illustrative, not Dropbox's code, but it shows the shape of the rule:
# atlas/servlets/sharing/BUILD (illustrative)
py_library(
name = "sharing_servlet",
srcs = glob(["*.py"]),
deps = [
"//atlas/common/auth", # shared, owned by platform
"//atlas/common/storage",
],
# Only this servlet's own targets and its gRPC entrypoint may depend on it.
visibility = [
"//atlas/servlets/sharing:__subpackages__",
"//atlas/serving:__pkg__",
],
)
The trade-off: someone has to decide what a servlet is. Too coarse and you rebuild a small monolith with a shared release train. Too fine and you pay cluster overhead for a single endpoint. Dropbox's ratio, roughly 25 routes per servlet on average, says the unit was a feature, not an endpoint. The cost is the refactoring itself: breaking cycles in 3 million lines of Python is slow, unglamorous and has to happen before any traffic moves.
Mechanism 2: one cluster per servlet, operated by the platform
Each Atlasservlet runs as its own cluster. That gives isolation (a crash or memory leak in one servlet stays there), independent pushes, and consistent tooling, because every cluster is built from the same template. The developer writes endpoint interfaces and implementations. The Atlas team owns pushing and monitoring the clusters. The authors describe the developer experience as serverless-like, comparable to AWS Fargate, while underneath it is a fleet of automatically provisioned services.
Two automated loops make that ownership split realistic. The first is canary analysis: every service has canary, control and production deployments. Canary and control receive a small share of traffic, metrics such as CPU and route availability are compared between them, and a bad push stops automatically and notifies the owner. The design is described as very similar to Netflix's Kayenta. Comparing canary to a control group running the old version, rather than to production at large, removes the noise of time-of-day and traffic mix.
The second loop is autoscaling. The autoscaler keeps each cluster above 40% free capacity headroom, using Envoy's Load Reporting Service and request queue length as signals. That headroom number is the price of not asking product teams to do capacity planning. Forty percent idle is expensive at Dropbox's scale, and it is the explicit cost the platform pays so that 200 servlets do not each need a capacity owner.
The trade-off: the platform team becomes a single point of organisational failure. If Atlas has a bad template, every servlet inherits it. Dropbox accepts that because one team getting operations right once is cheaper than dozens of teams getting it partially right.
Mechanism 3: a serving stack that lets the same endpoint run in both worlds
Atlas standardised on gRPC. Existing HTTP traffic is served through Envoy's gRPC-HTTP transcoding, so public clients did not have to change. An adapter converted existing endpoints to the gRPC interface, which meant the same endpoint code could run on Metaserver and on Atlas during the migration. Dropbox also replaced its custom Bandaid proxy with open-source Envoy.
This is what made the migration incremental instead of a cut-over. Traffic for a route could move to Atlas, and move back, without a rewrite. Behaviour was checked with byte-by-byte comparisons of outputs between the legacy and new paths. The team moved internal gRPC traffic first and left the riskier web and HTTP transcoding paths for later. Hidden assumptions surfaced along the way, for example infrastructure services that trusted Metaserver's identity, and each one needed its own monitored rollout.
The migration principle the team names is "stepping stones, not milestones": each step had to deliver value on its own, even if the project died after it. Faster Metaserver test frameworks, memory efficiency improvements, and a load test later reused for hardware validation all paid off before Atlas carried meaningful traffic. At the time of writing, Atlas served more than 25% of former Metaserver traffic, with the rest validated in tests.
There is one more detail worth noticing: local development merges the Atlasservlets back into a monolith, with Bazel rules hiding the merge. Developers keep the fast inner loop of a single process. Production gets the isolation of separate clusters. The deployment topology and the development topology are two different views of the same code.
What this changes compared with the principles you know
Domain-Driven Design tells you where the boundaries are. It does not tell you whether a bounded context deserves its own process, its own on-call rotation and its own capacity plan. Atlas answers that question explicitly: a boundary deserves its own deploy and its own failure domain, but not its own operators.
Compared with a modular monolith of the Shopify kind (issue 5 of this series), Atlas goes one step further. Shopify enforces boundaries in the code and keeps one deployable. Dropbox enforces boundaries in the code and then turns each bounded unit into its own cluster, because the shared release train was the main source of pain. If your monolith hurts because of coupling, a modular monolith is enough. If it hurts because one team's bug rolls back everyone's release, you need the deploy split as well.
Compared with classic microservices, Atlas separates the deployment unit from the operational unit. The servlet is the unit of release and isolation. The platform is the unit of operations. That is close to how internal developer platforms are described today, but Dropbox reached it from the opposite direction: by trying microservices and measuring what they cost.
What to steal for your architecture
Adopt this shape when three conditions hold: a monolith that many teams change every day, release coupling as a real and measured pain (rollbacks caused by unrelated code), and enough scale to fund a platform team. Do not adopt it if you have one or two teams, if your deploys are already cheap and rarely rolled back, or if no one can own a shared serving platform full time. In those cases the cluster-per-unit overhead buys nothing.
For one team: do not split anything. Steal the first mechanism only. Reorganise code into feature directories, add an import-boundary check to CI, and break cycles now, while they are cheap. Dropbox's own lesson is that code composition early in a project's life is what compounds.
For ten teams: keep a modular monolith, but make the deploy unit configurable. Build the same artefact once and run it as a few pools, each serving a subset of routes behind the proxy. Add automated canary-versus-control comparison before you add any new service. You get most of the isolation benefit without a platform team.
For a hundred teams: this is Atlas territory. Create a platform team that owns the serving template, canary analysis and autoscaling, define the servlet as a group of routes owned by one team and enforced by the build, and make every servlet a cluster from the same template. Reserve real independently operated services for shared capabilities with stable contracts, like identity, which is exactly where Dropbox's SOA work succeeded.

