What Are Micro-Frontends? When They Help
On this page
Five teams, one release train
Picture an online shop with five product teams: search, catalog, cart, checkout and account. The backend was split into services years ago, so each team ships its API whenever it wants. The frontend is still one React app in one repository. Every change waits for the same build, the same test run and the same weekly release. A typo fix in the account page waits behind a risky checkout change.
That's the problem micro-frontends solve. A micro-frontend is a part of the user interface that one team owns from the database to the pixels, and can deploy on its own. The page the user sees is assembled from several of them at build time, on the server or in the browser.
Think of a food court rather than one restaurant. Each stall cooks and serves on its own schedule, and the shared seating area holds it together. The analogy breaks in one place: diners never notice the stalls, so the shared parts, the layout, the design and the login, still have to feel like one product.
What changes, and what you pay for it
| One frontend | Micro-frontends | |
|---|---|---|
| Deploys | One pipeline, everyone together | One pipeline per team |
| Ownership | Shared code, shared bugs | A team owns a slice end to end |
| Technology | One framework version for everyone | Can differ, but usually shouldn't |
| Performance | One bundle, easy to optimize | Risk of duplicate libraries and extra requests |
| Consistency | Comes for free | Needs a shared design system and rules |
| Operations | One thing to monitor | Several deployments that must work together |
The left column isn't bad. For most teams it's the right answer, because the costs on the right are real: more build tooling, more ways for pages to break, and more effort to keep the experience consistent.
Signs you need them
Micro-frontends pay off when the bottleneck is coordination between teams, not code. Look for these signs:
- Several teams change the same frontend every week and wait on each other to release.
- The backend is already split by business area, and the frontend is the last shared piece.
- Parts of the app have very different rates of change, such as a stable account area and a checkout that changes daily.
- You're migrating gradually from an old frontend, and new parts must live next to old ones for a year or more.
And signs you don't:
- One or two teams own the whole frontend.
- The pain is slow builds or messy code, which better tooling and modules inside one app can fix.
- You'd split by technical layer, such as "the components team", rather than by business area.
The rule that matters most
Split the frontend the same way you split the teams. Martin Fowler's article on micro-frontends, written by Cam Jackson, frames them as an extension of the same idea behind microservices: independent delivery by autonomous teams. If the split doesn't match team boundaries, you get all of the costs and none of the independence. Day 2 covers how to draw those boundaries.
Check yourself
The real problem is build speed, not team coordination, and micro-frontends are a solution to the second. Better caching, code splitting or a faster bundler fixes slow builds without adding a shell, an import map, several pipelines and new ways for the page to break. Micro-frontends earn their cost when several teams keep blocking each other.
It can build, test and deploy its part of the UI on its own schedule, without waiting for other teams' changes to be ready or for a shared release train. It also owns the results: its errors, performance budget and user feedback. That autonomy is the main reason to accept the extra complexity.
Any two of: more build and deployment tooling to run, the risk of loading shared libraries such as React more than once, extra effort to keep design and behavior consistent, harder end-to-end testing, and more ways for the assembled page to fail. Each of these needs an owner before you split.
Usually not yet. Splitting before the teams exist means guessing at boundaries and paying the operational cost early. Keep a well-structured single app with clear modules that match the expected business areas, so it can be split along those lines when the teams arrive.
A component library is installed at build time and released together with the app that uses it, so it doesn't give independent deployment. A micro-frontend is a slice of the product owned by one team, loaded and deployed on its own schedule, often including its own data fetching and routes.