Problems they solve
Identify the real drivers for micro frontends, team autonomy, independent deploys, scaling across many teams and incremental migration, and tell them apart from problems micro frontends don't fix.
The real driver is people
Micro frontends are mostly about teams, not code. When several teams work on one frontend, they keep stepping on each other: the same build, the same release, the same files.
The idea is to let each team own a part of the product completely, so it can decide and ship without waiting for others. Cam Jackson calls these autonomous teams, each owning a slice of the product from idea to production.
Natalia Venditto makes the same point: splitting a frontend mainly solves organizational problems, such as teams working on features with different development cycles. Her advice is to ask whether you really have those problems before choosing micro frontends.
Jackson recommends slicing teams around what users see, often a whole page or feature, rather than around technical layers. A team that owns “checkout” can change its page end to end; a team that owns “styling” has to coordinate with everyone.
Geers adds that each team should be able to choose and upgrade its own stack without coordinating with other teams. In practice many organizations keep one framework for consistency and hiring, and use the separation mainly for ownership and release independence.
Shipping without waiting
In one shared frontend, every change rides in the same release. If one team’s work is not ready, others wait, or the release goes out with a half-finished feature hidden behind a flag.
With micro frontends, each piece has its own pipeline to production. Jackson’s point is that a team’s release should not depend on the state of anyone else’s codebase.
The demo below plays one week of finished work both ways: on a shared release train, and with each team deploying on its own.
Independent deploys
Two teams finish three changes in one week: Team A's v2 on Monday, Team B's fix v1.1 on Wednesday and Team A's v3 on Thursday. With a release train, everything ships together on Friday, so finished work waits: v2 for 4 days, the fix for 2 and v3 for 1, 7 team-days in all, for one release. With independent deploys, each change goes live the day it is ready: three releases, no waiting, and Team B never has to coordinate with Team A. The days are illustrative.
This only holds when the pieces are composed at runtime or on the server. If each piece is a package bundled into the shell at build time, the shell still has to rebuild and release for any change to reach users, and teams are back to sharing a release.
Independent deploys move work elsewhere: each team now needs its own pipeline, environments and a way to roll back its piece without breaking the page.
Smaller codebases
Each micro frontend is a smaller codebase than the whole app. A team can understand all of its own code, and it is harder to reach into another team’s code by accident.
Jackson notes a side effect: sharing domain models between micro frontends becomes harder on purpose, which pushes teams toward clearer, more explicit contracts.
Smaller does not mean simpler overall. The total amount of code, pipelines and infrastructure usually grows. What shrinks is what each team has to hold in its head.
Changing an old frontend piece by piece
Rewriting a large legacy frontend in one go is risky and slow. Micro frontends offer another path: replace one part at a time, while the rest keeps running.
Jackson describes this as an incremental upgrade: a new piece built with new tools sits next to the old ones, and the old app shrinks piece by piece instead of everything stopping for one big upgrade.
Try both plans on the same shop and compare when users first get something new.
Strangler fig migration
A router sits in front of a legacy shop that serves /search, /product, /cart and /checkout. Route by route, the team rebuilds one route at a time, about two weeks each, and points the router at the new code as soon as it is ready: /search goes live at week 2, /product at week 4, /cart at week 6 and /checkout at week 8, while the legacy app keeps serving everything not yet moved. If a new route misbehaves, the router sends it back to legacy without a rebuild, and once nothing routes to legacy, the legacy app can be removed. A big-bang rewrite takes the same eight weeks, but nothing reaches users until all four routes switch at once at week 8. By then, route by route has had 12 route-weeks live, against none. The weeks are illustrative.
The same works for framework upgrades. One team can move its piece to a new framework version while others stay where they are, instead of the whole app upgrading on one date.
This is the strangler fig pattern applied to the frontend. Martin Fowler’s version of the idea: build the new system around the edges of the old one and let it grow, until the old system can be switched off.
What they don’t solve
Micro frontends are a fix for coordination between teams. In our view they are not a fix for:
- Slow pages. Separately loaded pieces usually add requests and can duplicate libraries.
- A messy codebase in one team. Splitting it adds deploys without removing the mess; better module boundaries are cheaper.
- Unclear ownership. If nobody knows who owns what, splitting the code just moves the confusion.
A quick test before adopting them: name the teams that would own each piece, and the waiting you expect to remove. If you can’t name more than one team, or there is no waiting, the next lesson is the one to read.
Recap and check
Four things to remember
- The real driver is people.Micro frontends remove waiting between teams that share one frontend, not problems in the code itself.
- Each team ships without waiting.A finished change reaches users through its own pipeline, as long as the pieces are composed at runtime or on the server.
- Old frontends can be replaced piece by piece.New code takes over one part at a time while the legacy app keeps running, so users get something new sooner.
- They don’t fix slow pages, messy code or unclear ownership.Splitting adds deploys without removing those causes; in our view cheaper fixes come first.
Check yourself
0 of 2 answered · nothing is scored or saved- 1
- 2
Team B finishes a fix on Monday. In a shared frontend release, Team A's half-done feature blocks the Tuesday release. Which benefit of micro frontends targets this?
Show answer
Answer: A. Independent deployment
- A: With its own pipeline, Team B's fix goes out when Team B is ready, whatever state Team A's code is in.
- B: Micro frontends often make total download size larger, not smaller. The problem here is waiting on another team, not bytes.
- C: Splitting can make accidental coupling harder, but nothing here is about quality. Team B is waiting on a shared release.
A single team of five has a slow, messy frontend. Which problem would micro frontends most likely solve for them?
Show answer
Answer: C. Probably neither
- A: Splitting into separately loaded pieces usually adds requests and can duplicate libraries. Performance work is a separate job.
- B: One team splitting its own code into separately deployed apps adds pipelines and coordination without removing the mess. Better module boundaries are cheaper.
- C: In our view, yes. Micro frontends solve coordination between teams. One team has little of that to remove, so it pays the costs without the main benefit.