A 15–30 person engineering organisation can outgrow one release queue without outgrowing one Vue application. My default would be a modular Vue frontend over independently owned backend services, not runtime microfrontends. Split the browser application only when separate teams are repeatedly blocked from releasing independently—and when they can operate the extra contracts, failure modes, and production diagnostics that the split creates.
One Vue deployment is the better default until release coordination becomes the bottleneck
Consider three product squads sharing a customer-facing application. Each squad owns API changes, but all three contribute to the same frontend. A single Vue deployment may look like an ownership problem; it may instead be a scheduling problem. If a pull request can pass its checks and ship without waiting for another squad’s unfinished work, splitting the browser bundle will buy little. If every release requires negotiating a shared test window, there is a stronger case for separation because the deployment unit is constraining the teams.
I would start with Vue 3, Vue Router 4, TypeScript 5, and a Vite-built application divided into domain modules. Each module gets an owning squad, its own routes, and a documented public interface. pnpm workspaces can keep shared packages local without turning internal imports into public contracts. Backend microservices can still deploy separately: a frontend deployment boundary does not have to mirror every service boundary, because users experience a workflow rather than an organisation chart.
Microservices and Vue.js Microfrontends Team Scaling makes team autonomy a compelling goal, but a separate browser runtime is not the necessary first step when code ownership and release discipline can remove the same queue. I would not create one microfrontend per squad on an organisation chart, because squads change faster than user journeys and the resulting cross-app navigation becomes a permanent integration obligation.
For a team of 22 engineers, three frontend ownership areas are an illustrative staffing model, not a measured optimum. Assign each area an owner for reviews, incidents, and dependency upgrades, then allow contributions across boundaries through ordinary pull requests. This retains a single route tree and one accessible navigation system while making accountability visible. A monorepo can support that arrangement, but only if its CI runs affected tests reliably; a repository layout alone cannot make a release independent.
Before considering a split, record blocked releases for four weeks. Count a release as blocked only if one squad’s ready change waits on another squad’s code, approval, or regression fix. Do not count a failed test in the change itself, because runtime separation would not cure it. Also record lead time from approved pull request to production, rollback time, and the number of cross-squad changes per customer journey. Those observations distinguish genuine deployment coupling from the ordinary cost of working on the same product.
Runtime microfrontends win when independent releases outweigh integration costs
The two options are a modular Vue application with one frontend deployment and runtime Vue microfrontends with separate frontend deployments. The modular application wins when squads frequently change the same journeys, share navigation and state, or already release without waiting on one another. Its cost is a shared frontend release train and the need to enforce module boundaries in code review. Runtime microfrontends win when teams own stable, mostly separate journeys and need to deploy or roll back them on different schedules. Their cost is version compatibility, additional loading paths, shared-runtime governance, and harder end-to-end diagnosis.
Use a decision threshold rather than an architectural preference. As an initial value to tune, I would ask whether at least two squads have needed separate frontend releases twice a week for six consecutive weeks. That threshold is deliberately demanding because the runtime split adds recurring work even in weeks when no team ships. Another adjustable signal is whether more than 30% of otherwise-ready frontend releases waited on unrelated work. If the delays come from a single slow approval policy, change the policy first; separate deployments behind the same approval queue will still wait.
Scaling Web Applications with Vue.js and Microfrontends puts frontend scaling on the table, but I would require evidence of deployment or ownership pressure before treating runtime composition as the answer. More users alone do not justify more browser applications, because CDN caching, API capacity, and database contention can dominate the load while the frontend remains one deployable artifact. Use Lighthouse CI and real-user Core Web Vitals to identify a browser performance problem; use release data to identify an organisational one.
If runtime composition wins, draw the boundary around a route or complete workflow, not a button or shared header. A separately owned account area can have a clear entry, exit, and rollback path. A remotely loaded price widget inside a checkout page cannot, because its team must coordinate every state and error-handling change with checkout. Start with one boundary where the consuming shell can show a useful failure state if the remote does not load. That constraint matters because independent deployment is only valuable when a failed deployment can also be contained.
Webpack 5 Module Federation is one possible runtime mechanism; choosing it does not require migrating a healthy Vite application merely to test an organisation hypothesis. Prototype the selected route with the intended host and remote build tools first. If the prototype needs extensive adapters for shared Vue instances, routing, or CSS, include that maintenance in the decision rather than calling it a one-time migration expense.
Independent deployments require fewer shared contracts, not more shared state
A runtime split moves compatibility decisions from build time to production. The shell and a remote may be deployed minutes or days apart, so they must agree on the route they own, the inputs they accept, the events they emit, and what happens when one side is unavailable. Keep that surface small: pass a user identifier or scoped capability, not a mutable Pinia store. A shared store couples release schedules because a store-shape change can break an older remote even though both deployments succeeded.
Keep API contracts explicit as well. OpenAPI 3.1 can describe HTTP request and response shapes, while Pact can test a particularly risky consumer-provider interaction; neither proves that a multi-step customer journey still works, so retain Playwright tests for those paths. For browser-to-service calls, prefer the application’s existing authenticated API boundary over passing raw credentials between remotes, because credentials broaden the consequences of a compromised or misconfigured bundle. Treat event names and payloads as versioned interfaces, with a documented period during which old and new consumers both work.
The delivery mechanism needs equally clear rules. Serve the shell’s HTML with Cache-Control: no-cache so clients revalidate references after a deployment, and serve content-hashed JavaScript assets with Cache-Control: public, max-age=31536000, immutable so unchanged files remain cacheable. Do not give a mutable remote entry that year-long policy, because a browser or CDN could retain a pointer to an obsolete deployment. Configure Content Security Policy to allow only the intended remote origins, and test the policy in staging before enforcement because a blocked script otherwise resembles a broken remote release.
The following Bash smoke check runs against a deployed shell URL and fails if the HTML cannot be fetched or does not advertise revalidation. It checks one delivery contract, not whether a remote works:
#!/usr/bin/env bash
set -euo pipefail
url="${1:?pass a deployed shell URL}"
headers="$(mktemp)"
trap 'rm -f "$headers"' EXIT
curl --fail --silent --show-error -D "$headers" -o /dev/null "$url"
grep -qi '^content-type: text/html' "$headers"
grep -qi '^cache-control: .*no-cache' "$headers"
echo "Shell reachable; HTML is revalidated"
Run that check against the CDN endpoint rather than only the origin, because an origin can return correct headers while an edge cache changes them. Add a separate check for a deployed remote’s availability and a Playwright journey that opens its route from the shell. These checks belong to different owners: the platform team can own delivery headers, while the journey owner must own what a user sees when the remote fails.
A pilot should prove rollback and diagnosis before it proves autonomy
Give the first runtime microfrontend a limited route and an explicit fallback. Budget two weeks as a planning assumption for the pilot, including an independent deploy, a failed-load exercise, and a rollback drill; extend the budget if the team has no existing browser observability. A demo that loads two bundles on a laptop proves composition, but not the claim that squads can safely release separately.
Instrument the shell and remote with OpenTelemetry trace context where requests cross service boundaries, and tag frontend errors with the shell version, remote version, and route. Prometheus can track server-side availability, while browser error reporting should show whether users hit a remote loading failure or an application exception. Set a provisional guardrail of 1% for remote-load failures during the pilot, then tune it to traffic and the journey’s importance. The point of the guardrail is to make rollback a rehearsed decision rather than a debate during an incident.
Compare the pilot against the original application using the same release measures. Did approved changes reach production sooner? Could the remote roll back without redeploying the shell? Did Playwright failures become easier or harder to assign? Check p75 interaction latency for the affected route as well, because independent deployment is a poor trade if loading the remote makes a common interaction noticeably slower. Keep the modular application if release waiting barely changes or if every remote change still requires coordinated shell changes; the pilot has then identified a boundary that is not independent.
Start by measuring the queue you intend to remove
Tomorrow, add a “blocked by another frontend change” reason to your release log and assign someone to review it after four weeks. Record the waiting time, the affected journey, and whether a smaller module boundary or a policy change could have avoided it. If the same stable journey repeatedly blocks another squad’s release, pilot that boundary. Otherwise, keep one Vue deployment and spend the saved operational effort on making it easier to ship.


