TL;DR
- A Webpack 5 host shell composes Rsbuild remotes at runtime, so a team deploys its remote without redeploying anyone else.
- A typed federation contract turns a breaking change between host and remote into a compile error instead of a production incident.
- Registry-driven routing, RBAC and per-remote error boundaries are platform concerns, solved once instead of by every team.
Key figures
- Independent remotes
- 5
- Cross-team deploy coordination
- 0
The problem
A shared frontend eventually stops being a technical problem and becomes a coordination problem. When several teams contribute to one application, every release is everyone's release: one team's unfinished change blocks another team's fix, and the deploy queue becomes the real bottleneck.
The Developer Experience Platform is my answer to the question that problem keeps asking — how do five teams deploy independently without breaking each other? It is a personal project that models an internal platform the way a large organisation would run one, built as a working system rather than a diagram on a slide, and it is open source.
Constraints
- Each team owns its release cadence. Nothing one team ships should require another team to rebuild or redeploy.
- It is still one product. Navigation, permissions and the visual language have to feel like a single application, not five sites stitched together.
- A failure stays local. A bug in one team's code must not take the page down for everyone else.
Architecture
A host shell, built with Webpack 5, owns the platform's concerns:
authentication, navigation, route orchestration, role-based access control,
error boundaries and telemetry. Its static remotes map is deliberately
empty. At runtime it fetches a registry — the source of truth for every
remote's route, URL, version, permissions and enabled state — and loads each
remote through Module Federation when its route is first visited.
Five remotes, each built with Rsbuild, own the product: feature flags,
experiments, logs, an API explorer and documentation. Each exposes exactly one
thing, a mount(container, props) function, and nothing else crosses the
boundary.
Three shared packages keep the system coherent without coupling the teams to each other: the federation contracts, a UI package of primitives and design tokens, and an observability wrapper that records how long each remote takes to load. The whole platform lives in a Turborepo monorepo.
Decisions and trade-offs
Runtime compositionoverBuild-time packages
If each team's code were an npm package, the host would have to rebuild and redeploy to pick up any change, which puts every team back on the same release train. Here the shell imports no remote statically: adding, disabling or re-pointing one is a change to the registry, not to the shell. The cost is that integration now happens in the browser, which is what the next decision is for.
Contracts checked twiceoverTrusting the boundary
At runtime, a mismatch between host and remote is a blank screen. The contracts are TypeScript interfaces, which catch a breaking change at compile time, and Zod schemas, which check the data that actually arrives: the registry is validated before the shell reads it, and every remote's mount function is validated before the shell calls it.
An isolated router and cache per remoteoverShared global state
Every remote mounts with its own in-memory router, so the shell stays the only owner of the URL, and with a fresh query cache, so no remote can read or corrupt another's data. Unmounting releases both. Teams lose the convenience of reaching into shared state, which is the point.
Failure isolated per remoteoverOne error boundary for the app
Each remote loads with a timeout and a retry, renders inside its own error boundary, and fails into a retry screen of its own. A broken remote degrades one route; the shell, the navigation and every other remote keep working.
A scaffolding CLIoverCopying the last remote
create-mfe generates a new remote already wired for Rsbuild, Module
Federation, the contracts, the shared design tokens and a test setup with
coverage thresholds. Then a registry entry puts it live. The platform's
conventions are encoded in a tool rather than in tribal knowledge.
Results
Five remotes deploy independently, and shipping one requires no coordination with the others: the two figures at the top of this page are properties of the architecture, not of a good week. The concerns every team would otherwise solve for itself — routing, permissions, failure handling, telemetry, the design language — are solved once, in the platform.
The quality bar is part of the design, because distributed frontends fail at their boundaries: strict TypeScript, a mount-contract test in every remote, 80% coverage thresholds, and CI running lint, types, tests and builds across the monorepo.