
Are micro frontends worth the complexity? Count your teams and deploys first
If you lead several teams on one frontend, the split is a bet on hours. Count who waits on whose release, price what the split adds each week, and keep the monolith when the waiting is small.
Are micro frontends worth the complexity for your team?#
Micro frontends are worth the complexity only when several teams ship one frontend and lose real time every week waiting on each other's releases. In the illustrative model below, three teams that each deploy twice a week land close to break-even. However, one team never gains at any cadence, since it has no peer to wait on.
The single-spa frequently asked questions (FAQ) page makes the same call about its own tool. For a small project or a small team, "we would recommend you stick with a monolith" until scaling gets hard. Because that advice comes from the project that builds a micro frontend router, it carries weight.
- Gain
- is the weekly hours of release waiting the split removes.
- Cost
- is the weekly hours a shell, contract tests and rollback checks add.
What does the split buy, and what does it cost every week?#
The split buys each team the right to deploy without waiting on the others, and it charges a shell, contract tests and rollback checks every week. In a shared release, each deploy waits on the other teams in the train. As a result, the loss grows with every peer and every deploy.
The cost has three parts. First, a fixed platform cost covers the shell, the shared dependencies and the pipeline. Second, each team pays for contract tests and version alignment. Third, each deploy needs a compatibility check, because rollback is no longer atomic.
For example, say three teams each deploy twice a week, and each shared deploy loses 2 hours per peer. In this illustrative case, that is 2 deploys times 2 peers times 2 hours, or 8 hours a week. Then say the split costs 4 platform hours, 1.5 hours per team and a quarter hour per deploy. Those illustrative costs add up to 4 plus 4.5 plus 1.5, or 10 hours. So the gain covers about four fifths of the cost: a balanced trade, not a clear win.
Balanced trade
Coordination cost roughly matches release velocity gain.
Coordination overhead: 10 hours/week
Release velocity gain: 8 hours/week
Ratio: 0.8x → Roughly balanced
Full comparison table
| Teams | Deploys/wk | Coordination (hr) | Release Gain (hr) | Verdict |
|---|---|---|---|---|
| 1 | 1 | 5.8 | 0 | Monolith is faster |
| 1 | 2 | 6 | 0 | Monolith is faster |
| 1 | 4 | 6.5 | 0 | Monolith is faster |
| 3 | 1 | 9.3 | 4 | Monolith is faster |
| 3 | 2 | 10 | 8 | Balanced trade |
| 3 | 4 | 11.5 | 16 | Balanced trade |
| 5 | 1 | 12.8 | 8 | Monolith is faster |
| 5 | 2 | 14 | 16 | Balanced trade |
| 5 | 4 | 16.5 | 32 | Micro frontends justify the cost |
| 10 | 1 | 21.5 | 18 | Balanced trade |
| 10 | 2 | 24 | 36 | Balanced trade |
| 10 | 4 | 29 | 72 | Micro frontends justify the cost |
This calculator uses an illustrative coordination-cost model calibrated to Nx and Module Federation operational patterns. Your team's actual overhead depends on testing discipline, shared-code governance, and deployment automation. Adjust this model to match your own deployment history.
With five teams at three deploys a week, the same illustrative model gives 24 hours gained against about 15 of overhead. With one team, the gain is zero at any cadence. Swap in your own hours first.
Which deployment-scale signals justify micro frontends?#
The signals are organisational: teams blocked on each other's releases, deploy windows, and builds Vercel flags at over 5 minutes, per its guidance read in November 2026. Vercel's chapter on when the pattern makes sense lists five symptoms. A long build means too much code compiles for every change. Blocked teams mean the shared codebase creates coordination overhead. A "don't touch that file" habit shows fear of breaking unrelated features. Deploy windows mean you can only ship at set times. Finally, slow local start-up is the fifth.
Vercel's two build-time lines, in its November 2026 guidance, bracket the choice: over 5 minutes is a symptom, and under 3 means faster tooling first.
Show data table
| Item | Value |
|---|---|
| build time that signals too much code compiling per change | 5 minutes |
| build time under which faster tooling comes first | 3 minutes |
Over 5 minutes is a symptom; under 3 minutes, faster tooling comes first.
Then measure before you decide. The metrics guide from DevOps Research and Assessment (DORA) defines deployment frequency as deployments over a period. It defines change lead time as the time from commit to production. For instance, if one team's merged work sits undeployed while another finishes, lead time shows the queue. However, DORA warns against turning a metric into a goal, so read these as symptoms, not targets.
What do shared dependencies cost after the split?#
A change to a shared library forces every app that consumes it to redeploy, as Nx documents, so shared dependencies quietly bring the release train back. Module Federation is the runtime loading of separately built code. In the words of the Nx guide, "When you change a shared library, Module Federation forces every app that consumes it to redeploy." So a design system or a framework upgrade still moves in step.
Since only one copy of a library can win at runtime, someone has to pick it. The webpack docs give the rule: "a consumer gets the highest version in the scope that satisfies its range". Meanwhile, the single-spa FAQ recommends an import map, a browser lookup table for module URLs, so each library is defined once.
Either way, the cost lands on people. For instance, if five teams share one component library, every breaking change becomes a five-team release. As a result, the per-team cost never falls to zero. That is why team autonomy and governance for micro frontends matters as much as the split.
What does the drop from 75.4% to 23.6% actually tell you?#
In The Software House's State of Frontend survey, micro-frontend use fell from 75.4% of respondents in 2022 to 23.6% in 2024, read in November 2026. The drop is a smaller share of each edition's respondents, not a count of teams that left.
75.4%
2022 edition
23.6%
2024 edition
The drop is a smaller share of each edition's respondents, not a count of teams that left.
| Option | % of each edition's respondents; each edition surveys a different set of respondents |
|---|---|
| 2022 edition | 75.4% |
| 2024 edition | 23.6% |
Because the survey asks a new sample each edition, the two figures describe different groups. Luca Mezzalira, a solutions architect at Amazon Web Services (AWS), wrote its micro frontends commentary. "Some companies that didn't truly need micro-frontends attempted to implement them, partly explaining the decline," he writes. He adds that many companies found the pattern can "demand organizational and cultural changes, which they weren't ready for". He also points to more investment in server-side rendering (SSR) and static-site generation (SSG), which share many of the same ideas.
In the 2024 edition, fewer than one respondent in four had used the pattern in the past year.
Show data table
| Segment | Value (%) | Share |
|---|---|---|
| Yes | 23.6 | 23.6% |
| No | 76.4 | 76.4% |
In the 2024 edition, fewer than one respondent in four had used the pattern in the past year.
In short, the figure confirms the test rather than replacing it. The pattern narrowed toward the organisations whose release friction pays for it.
When are micro frontends the wrong fit, and what fits instead?#
Stay monolithic when one team ships the frontend or every screen shares one flow; single-spa's own FAQ tells a small team to stick with a monolith. Vercel's November 2026 guidance names five wrong cases. For fewer than 5 developers, "The coordination overhead isn't worth it." For builds under 3 minutes, try faster tooling first.
The other three are a tightly coupled user experience (UX), a single domain of expertise, and "we might scale someday". Vercel also names the overhead: "duplicated auth checks, more complex debugging, additional configuration."
Each case has a better tool. For example, a checkout that runs from cart to payment in one session is tightly coupled. Splitting it puts a runtime contract at every step, so keep one app with module boundaries. When everyone works on everything, there is no team line to cut along. Instead, keep one codebase and one release. For the someday case, write down the signal that would change the answer and check it each quarter. The monolith is a decision you keep making, not a failure.
| Wrong case | What fits instead |
|---|---|
| Fewer than 5 developers | Stay monolithic: "The coordination overhead isn't worth it." |
| Builds under 3 minutes | Try faster tooling first |
| A tightly coupled user experience (UX) | Keep one app with module boundaries |
| A single domain of expertise | Keep one codebase and one release |
| "We might scale someday" | Write down the signal that would change the answer and check it each quarter |
What should you try before splitting the frontend?#
Try module boundaries inside one app, affected-only builds and faster build tooling first, because each removes a signal without adding a runtime join. First, give each team a folder it owns, plus a lint rule that blocks imports across folders. That answers the "don't touch that file" habit without a second deploy.
Second, rebuild only what changed. In the Nx guide, the affected command computes the set of apps a change touches, then rebuilds and retests only those. Third, make the build faster: Vercel's November 2026 guidance says that under 3 minutes, try its Turbopack bundler first.
Module boundaries
Give each team a folder it owns, plus a lint rule that blocks imports across folders.
Affected-only builds
Rebuild and retest only the apps a change touches, as the Nx affected command does.
Faster build tooling
Under 3 minutes, try Turbopack first, per Vercel's November 2026 guidance.
Then measure again after a quarter. If the signals are gone, you saved the split's weekly cost. Also, the micro frontends vs monolith choice mirrors the backend one, as microservices vs monolith sets out.
If the signals say split, where do you start?#
Start from the integration options and setup in the Module Federation guide, since Module Federation was the solution 51.8% of respondents used in 2024. The Software House's State of Frontend 2024 survey puts single-spa second, at 35.5%.
Show data table
| Item | Value |
|---|---|
| Webpack 5 Module Federation | 51.8% |
| Single SPA | 35.5% |
| Open Components | 6.3% |
| SystemJS | 6.1% |
| Bit | 5.9% |
| Qiankun | 1.8% |
| Luigi | 1.5% |
| Piral | 1.3% |
Module Federation at 51.8% and single-spa at 35.5% lead every other solution.
The hub guide owns the next decision. It covers what micro frontends are and where Module Federation fits. It then compares each integration option and shows how to build with Module Federation. Also, each remote adds work to the first page load, which the Core Web Vitals cost of Module Federation measures. A team whose app runs on Next.js faces a narrower choice in 2026, so read how to split a Next.js app in 2026 for what the App Router supports.
Where to go from here#
Run the test on your own teams, then read the guide that fits your answer: the hub to split, the strangler pattern to migrate, governance to run it. To split, open the micro frontends and Module Federation guide. To move off a legacy app a route at a time, read the incremental strangler migration. Once the split is live, team autonomy and governance covers the rules.
For a team to build the split with you, see custom software development. For the per-team pipelines and rollback that independent deploys need, see DevOps and continuous integration and delivery (CI/CD). Still, the single-spa FAQ and Vercel's guide are enough on their own to run the test.