Build-time

Build-time packages

Each team publishes its feature as a versioned npm package. The shell installs those packages, builds once, and ships a single bundle.

How it works

@shop/team-aTeam A
@shop/team-bTeam B
react · design systemShared
shell build → one bundleShell
Solid lines: combined at build time · npm install
  1. Teams publish packages. Team A and Team B each release a versioned package to a registry.
  2. The shell installs them. The shell raises the package versions in its package.json and installs them.
  3. One build, one bundle. A single build compiles every team's code and the shared dependencies into one bundle. Shared libraries are included once, as long as every package accepts the same version.
  4. One release. The bundle ships. Any team's change goes through steps 2 to 4 again.

Pros

  • Simplest model and tooling: packages and one ordinary build.
  • One build, so shared dependencies are deduplicated when the packages agree on versions.
  • Teams import each other's code with normal, type-checked imports.

Cons

  • Every change needs the shell to rebuild and release.
  • Releases happen in lockstep: teams wait on one release train.
  • Package versions can drift between teams.

Best when

  • A few teams that are fine with a shared release.
  • Performance-critical pages where one optimized bundle matters.
  • Sharing a component library or design system.

Avoid when

  • Teams must deploy on their own schedule.
  • Several frameworks need to live in one product.
  • One team needs to ship fixes many times a day.

In code

shell/package.json · shell/src/App.jsx
// shell/package.json (excerpt)
{
  "dependencies": {
    "@shop/team-a": "^1.4.0",
    "@shop/team-b": "^2.0.0"
  }
}

// shell/src/App.jsx
import { Search } from "@shop/team-a";
import { Cart } from "@shop/team-b";

Tooling and ecosystem

There is no special tooling: any package registry (npm, a private registry or a monorepo’s workspace packages) and any bundler work. Cam Jackson’s article describes this approach and recommends against it for micro frontends, because releases happen in lockstep: a change to one part means recompiling and releasing all of them. It is still a reasonable choice when independent deployment is not what you need.