# Glossary

_Every micro frontend term in one sentence, with a longer explanation, sources and where it is taught._

## Build-time integration

Combining teams' pieces into one app when the shell is built, usually by publishing each piece as a package.

Build-time integration is simple and gives one optimized bundle. Jackson notes that it brings back a lockstep release process: to change one piece, the whole app is rebuilt and released. It is often the honest answer when teams do not need independent deploys.

Taught on:
- [Approach · Build-time packages](https://microfrontends.dev/approaches/build-time-packages)
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Composition

Putting several separately built pieces together into the one page a user sees.

Composition can happen at build time, in the browser at runtime, or on the server. Where it happens decides how independent the teams really are.

Taught on:
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com
- [Micro Frontends – extending the microservice idea to frontend development](https://micro-frontends.org/), Michael Geers · micro-frontends.org

## Contract

The agreed interface between pieces, such as events, URLs, props or APIs, that each side can rely on without knowing the other's internals.

When pieces are split apart, reaching into another team's code becomes harder on purpose, which pushes teams toward explicit contracts. Jackson recommends keeping communication between pieces small and explicit, for example through custom events or the URL.

Taught on:
- [Lesson · Problems they solve](https://microfrontends.dev/learn/problems-they-solve)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Coupling

How much one piece of code depends on the details of another, so that changing one forces changes or coordination in the other.

Micro frontends make some coupling harder, because pieces cannot reach into each other's code. Shared dependencies, shared state and a shared release bring it back, so teams still have to choose what they share.

Taught on:
- [Lesson · Problems they solve](https://microfrontends.dev/learn/problems-they-solve)
- [Lesson · When NOT to use them](https://microfrontends.dev/learn/when-not-to-use)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Exposed module

A module a Module Federation build makes available to other builds by listing it under its exposes option.

A remote decides which of its modules others may load, such as a page component or a mount function. The host loads an exposed module asynchronously and then evaluates it, so it only fetches the code it actually uses.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)

Sources:
- [Module Federation](https://webpack.js.org/concepts/module-federation/), webpack documentation
- [ModuleFederationPlugin](https://webpack.js.org/plugins/module-federation-plugin/), webpack documentation

## iframe

An HTML element that embeds a separate document inside a page, giving the embedded app its own window, styles and scripts.

iframes give the strongest isolation between pieces: styles and globals cannot leak across. They cost performance, accessibility, routing and layout work, and pieces can only talk through messages.

Taught on:
- [Approach · iframes](https://microfrontends.dev/approaches/iframes)

Sources:
- [<iframe>: The Inline Frame element](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/iframe), MDN Web Docs

## Independent deploy

Releasing one team's piece of the frontend without rebuilding or redeploying anyone else's.

Independent deploys are the main reason to choose runtime micro frontends: a team ships when its work is ready instead of waiting for a shared release. They cost extra pipelines, environments and runtime composition, which pay off little for a single team.

Taught on:
- [Lesson · Problems they solve](https://microfrontends.dev/learn/problems-they-solve)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Lifecycle functions

The bootstrap, mount and unmount functions each single-spa application exports so single-spa can start it, show it and remove it.

single-spa calls bootstrap once, mount when the application's route becomes active and unmount when it stops being active. Because every application has the same lifecycle, applications in different frameworks can share one page.

Taught on:
- [Approach · single-spa](https://microfrontends.dev/approaches/single-spa)

Sources:
- [Getting Started with single-spa](https://single-spa.js.org/docs/getting-started-overview/), single-spa.js.org

## Micro frontend

A piece of a web app's frontend that one team builds, tests and releases on its own, combined with other pieces into one experience for the user.

Cam Jackson defines micro frontends as an architectural style in which independently deliverable frontend applications are composed into a greater whole. Michael Geers frames it as extending the microservice idea to the frontend, with each team owning a feature from database to user interface. The term describes how the work is split between teams more than any one tool.

Taught on:
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com
- [Micro Frontends – extending the microservice idea to frontend development](https://micro-frontends.org/), Michael Geers · micro-frontends.org

## Modular monolith

One app with one build and one release, split into modules that teams own, with rules that stop modules from reaching into each other.

A modular monolith gives teams clear ownership without any runtime composition. Teams still share a release train, so it fits when a shared release is not the bottleneck. If it later becomes one, the module boundaries are a good starting point for splitting the app.

The modules are still deployed together. Venditto names that as the difference between a modular monolith and a distributed architecture such as micro frontends.

Taught on:
- [Approach · Modular monolith and monorepo](https://microfrontends.dev/approaches/alternatives)
- [Lesson · When NOT to use them](https://microfrontends.dev/learn/when-not-to-use)

Sources:
- [Enforce Module Boundaries](https://nx.dev/docs/features/enforce-module-boundaries), Nx documentation
- [boundaries](https://turborepo.dev/docs/reference/boundaries), Turborepo documentation
- [Modularization of a Monolith](https://microfrontend.dev/architecture/monolith-modularization/), Natalia Venditto · microfrontend.dev

## Module boundary

A rule about which parts of a codebase may import which others, checked by tooling so that teams' modules stay separate.

Nx enforces module boundaries with project tags and a lint rule, and Turborepo has a boundaries check for packages. Boundaries checked in CI give much of the separation teams want from micro frontends, without splitting the app at runtime.

Taught on:
- [Approach · Modular monolith and monorepo](https://microfrontends.dev/approaches/alternatives)

Sources:
- [Enforce Module Boundaries](https://nx.dev/docs/features/enforce-module-boundaries), Nx documentation
- [boundaries](https://turborepo.dev/docs/reference/boundaries), Turborepo documentation

## Module Federation

A bundler feature that lets an app load code from separately built and deployed apps at runtime, sharing dependencies between them.

Module Federation is built into webpack 5 as ModuleFederationPlugin. As of November 2026, the Module Federation project maintains Module Federation 2.0, which adds a runtime, a manifest and devtools, and lists webpack and Rspack as supported build tools.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)

Sources:
- [Module Federation](https://webpack.js.org/concepts/module-federation/), webpack documentation
- [Module Federation — Introduction](https://module-federation.io/guide/start/index.html), module-federation.io

## Monolith

A frontend built and released as one app, so every change from every team ships in the same build.

A monolith is not a mistake in itself: for one or two teams it is usually the simplest way to work. It becomes a problem when many teams change the same codebase and wait on each other's releases, which is the situation micro frontends are meant to address.

Taught on:
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)
- [Lesson · When NOT to use them](https://microfrontends.dev/learn/when-not-to-use)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Monorepo

One repository that holds many apps or packages, usually with shared tooling for building, testing and checking them.

A monorepo is about where code lives, not how it is deployed: the apps inside it can ship together or separately. Tools such as Nx and Turborepo can enforce boundaries between the projects in a monorepo.

Taught on:
- [Approach · Modular monolith and monorepo](https://microfrontends.dev/approaches/alternatives)

Sources:
- [Enforce Module Boundaries](https://nx.dev/docs/features/enforce-module-boundaries), Nx documentation
- [boundaries](https://turborepo.dev/docs/reference/boundaries), Turborepo documentation

## postMessage

A browser API that sends a message from one window to another, such as between a page and an iframe, even across origins.

The receiving window listens for the message event and should check the message's origin before trusting it. With iframes, postMessage is the main way the shell and a piece communicate, so the message format becomes their contract.

Taught on:
- [Approach · iframes](https://microfrontends.dev/approaches/iframes)

Sources:
- [Window: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage), MDN Web Docs

## Release train

A shared, scheduled release that every team's changes have to ride together.

On a release train, a finished change can wait for other teams' unfinished work, and one team's bug can hold up everyone. A modular monolith or build-time packages keep the train; runtime integration lets teams leave it.

Taught on:
- [Lesson · Problems they solve](https://microfrontends.dev/learn/problems-they-solve)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Remote

An app built and deployed separately whose modules the shell loads at runtime.

In Module Federation, remote modules are modules that are not part of the current build and are loaded at runtime from a remote container. The host lists each remote with a name and the URL of its entry file.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)

Sources:
- [Module Federation](https://webpack.js.org/concepts/module-federation/), webpack documentation

## remoteEntry.js

The small entry file a Module Federation remote publishes, which tells a host what the remote exposes and how to load it.

The host's configuration points each remote at this file's URL. When it loads, it registers the remote's container so the host can request its exposed modules and share dependencies with it. The file name is a convention, not a requirement.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)

Sources:
- [Module Federation](https://webpack.js.org/concepts/module-federation/), webpack documentation

## Root config

The single-spa setup that registers each application with a name, a function that loads it and the routes where it is active.

The root config is single-spa's version of the shell. It usually includes the shared HTML page and the code that calls registerApplication for every application, then starts single-spa.

Taught on:
- [Approach · single-spa](https://microfrontends.dev/approaches/single-spa)

Sources:
- [Configuring single-spa](https://single-spa.js.org/docs/configuration/), single-spa.js.org

## Runtime integration

Combining teams' pieces in the browser while the page runs, so each piece can be released without rebuilding the shell.

The shell loads each piece through JavaScript, Web Components or iframes. Runtime integration is what makes independent deploys possible, at the cost of more moving parts in the browser and extra requests before the page is complete.

Taught on:
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Shared dependency

A library, such as React or a design system, that several teams' pieces need and that may be loaded once for all of them or once per piece.

Loading a library once saves bytes but brings back coupling, because teams must agree on compatible versions. Loading it per piece keeps teams independent but makes users download it several times. Module Federation shares modules through a common share scope instead of bundling a private copy in each build.

Shared assets such as stylesheets and helper libraries are usually versioned and kept by a core team, often published to a registry like npm. Venditto notes that sharing them cuts duplication but means more interaction between otherwise independent teams.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)
- [Lesson · When NOT to use them](https://microfrontends.dev/learn/when-not-to-use)

Sources:
- [Module Federation](https://webpack.js.org/concepts/module-federation/), webpack documentation
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com
- [Micro-frontend and shared dependencies](https://microfrontend.dev/architecture/frontend-shared-dependencies/), Natalia Venditto · microfrontend.dev

## Shell

The app that owns the page layout and routing and loads or bundles the other teams' pieces into it.

Also called: Host.

Jackson calls it the container application: it renders common elements such as the header and decides which piece to show where. In Module Federation the shell is usually called the host, the build that lists remotes and loads them at runtime. The shell should stay small, because every team depends on it.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com
- [Module Federation](https://webpack.js.org/concepts/module-federation/), webpack documentation

## single-spa

A JavaScript framework that mounts and unmounts applications by route, even when they are written with different frameworks.

single-spa does not load code by itself; it decides which application is active and calls its lifecycle functions. It can be combined with import maps or Module Federation to load each application.

Taught on:
- [Approach · single-spa](https://microfrontends.dev/approaches/single-spa)

Sources:
- [Getting Started with single-spa](https://single-spa.js.org/docs/getting-started-overview/), single-spa.js.org

## Singleton

A shared dependency that Module Federation allows to load only once, so every piece on the page uses the same copy.

Some libraries, such as React, break when two copies run on one page, so they are marked as singletons. If pieces ask for incompatible versions, only one copy still loads and Module Federation prints a warning, unless strict version checking is turned on.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)

Sources:
- [ModuleFederationPlugin](https://webpack.js.org/plugins/module-federation-plugin/), webpack documentation

## Slot

A marked place on the shell's page where one team's piece is shown.

"Slot" is this site's word, not a term the sources define. In the browser, a slot is an element the shell renders, such as an empty container, that a team's code mounts into; Jackson describes the container application deciding which piece to show where. On the server, a slot is an include in the page template, such as an SSI or ESI include, that the composer replaces with the team's HTML fragment.

Taught on:
- [Approach · Module Federation](https://microfrontends.dev/approaches/module-federation)
- [Approach · Server and edge composition](https://microfrontends.dev/approaches/server-and-edge-composition)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com
- [Module ngx_http_ssi_module](https://nginx.org/en/docs/http/ngx_http_ssi_module.html), nginx.org
- [ESI Language Specification 1.0](https://www.w3.org/TR/esi-lang/), Mark Tsimelzon et al. · W3C (Note)

## Strangler fig pattern

Replacing a legacy system gradually, moving one part at a time to new code until the old system can be removed.

Martin Fowler names the pattern after strangler fig vines, which grow around a host tree until they replace it. Applied to the frontend, it means routing one page or widget to the new code at a time, which delivers value earlier and with less risk than a full rewrite.

Taught on:
- [Lesson · Problems they solve](https://microfrontends.dev/learn/problems-they-solve)

Sources:
- [Strangler Fig](https://martinfowler.com/bliki/StranglerFigApplication.html), Martin Fowler · martinfowler.com
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com

## Vertical split

Dividing a product so that each team owns a whole feature or page from the user interface down, rather than one technical layer.

Also called: Vertical slice.

Geers calls this organizing in verticals, with cross-functional teams that work through the whole stack for their feature. Jackson makes the same point: teams own vertical slices of the product, often a whole page, and he warns against splitting teams by technical layer.

Some authors use the term for composition instead. Natalia Venditto calls it a vertical split when each app loads at its own URL, and a horizontal split when pieces from several teams share one page or view.

Taught on:
- [Lesson · What are micro frontends](https://microfrontends.dev/learn/what-are-micro-frontends)

Sources:
- [Micro Frontends](https://martinfowler.com/articles/micro-frontends.html), Cam Jackson · martinfowler.com
- [Micro Frontends – extending the microservice idea to frontend development](https://micro-frontends.org/), Michael Geers · micro-frontends.org
- [Micro-frontend Architecture](https://microfrontend.dev/architecture/micro-frontends-architecture/), Natalia Venditto · microfrontend.dev
- [Micro-Frontends Splits - Vertical Split](https://microfrontend.dev/architecture/vertical-micro-frontend-split/), Natalia Venditto · microfrontend.dev

https://microfrontends.dev/glossary