Glossary · 27 terms
Every term, in one sentence
Each definition links to the lesson or approach where it’s taught.
Showing all 27 terms, A–Z
B
- Build-time integration
- Combining teams' pieces into one app when the shell is built, usually by publishing each piece as a package.
- Approach · Build-time packages →Lesson · What are micro frontends →
More about Build-time integration
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.
Source: Micro Frontends
See also: Runtime integration, Composition, Release train
C
- Composition
- Putting several separately built pieces together into the one page a user sees.
- Lesson · What are micro frontends →
More about Composition
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.
Sources: Micro Frontends, Micro Frontends – extending the microservice idea to frontend development
See also: Build-time integration, Runtime integration, Shell
- 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.
- Lesson · Problems they solve →
More about Contract
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.
Source: Micro Frontends
- Coupling
- How much one piece of code depends on the details of another, so that changing one forces changes or coordination in the other.
- Lesson · Problems they solve →Lesson · When NOT to use them →
More about Coupling
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.
Source: Micro Frontends
See also: Contract, Shared dependency, Module boundary
E
- Exposed module
- A module a Module Federation build makes available to other builds by listing it under its exposes option.
- Approach · Module Federation →
More about Exposed module
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.
Sources: Module Federation, ModuleFederationPlugin
See also: Remote, remoteEntry.js
H
- Host
- See Shell
I
- iframe
- An HTML element that embeds a separate document inside a page, giving the embedded app its own window, styles and scripts.
- Approach · iframes →
More about iframe
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.
Source: <iframe>: The Inline Frame element
See also: postMessage
- Independent deploy
- Releasing one team's piece of the frontend without rebuilding or redeploying anyone else's.
- Lesson · Problems they solve →
More about Independent deploy
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.
Source: Micro Frontends
See also: Release train, Runtime integration
L
- Lifecycle functions
- The bootstrap, mount and unmount functions each single-spa application exports so single-spa can start it, show it and remove it.
- Approach · single-spa →
More about Lifecycle functions
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.
Source: Getting Started with single-spa
See also: single-spa, Root config
M
- 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.
- Lesson · What are micro frontends →
More about Micro frontend
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.
Sources: Micro Frontends, Micro Frontends – extending the microservice idea to frontend development
See also: Composition, Independent deploy, Vertical split
- 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.
- Approach · Modular monolith and monorepo →Lesson · When NOT to use them →
More about Modular monolith
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.
Sources: Enforce Module Boundaries, boundaries, Modularization of a Monolith
See also: Monolith, Module boundary, Monorepo
- Module boundary
- A rule about which parts of a codebase may import which others, checked by tooling so that teams' modules stay separate.
- Approach · Modular monolith and monorepo →
More about Module boundary
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.
Sources: Enforce Module Boundaries, boundaries
See also: Modular monolith, Monorepo, Coupling
- Module Federation
- A bundler feature that lets an app load code from separately built and deployed apps at runtime, sharing dependencies between them.
- Approach · Module Federation →
More about Module Federation
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.
Sources: Module Federation, Module Federation — Introduction
See also: Remote, Shell, Shared dependency
- Monolith
- A frontend built and released as one app, so every change from every team ships in the same build.
- Lesson · What are micro frontends →Lesson · When NOT to use them →
More about Monolith
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.
Source: Micro Frontends
See also: Modular monolith, Micro frontend
- Monorepo
- One repository that holds many apps or packages, usually with shared tooling for building, testing and checking them.
- Approach · Modular monolith and monorepo →
More about Monorepo
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.
Sources: Enforce Module Boundaries, boundaries
See also: Modular monolith, Module boundary
P
- postMessage
- A browser API that sends a message from one window to another, such as between a page and an iframe, even across origins.
- Approach · iframes →
More about postMessage
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.
Source: Window: postMessage() method
R
- Release train
- A shared, scheduled release that every team's changes have to ride together.
- Lesson · Problems they solve →
More about Release train
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.
Source: Micro Frontends
See also: Independent deploy, Monolith
- Remote
- An app built and deployed separately whose modules the shell loads at runtime.
- Approach · Module Federation →
More about Remote
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.
Source: Module Federation
See also: Shell, Exposed module, remoteEntry.js
- remoteEntry.js
- The small entry file a Module Federation remote publishes, which tells a host what the remote exposes and how to load it.
- Approach · Module Federation →
More about remoteEntry.js
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.
Source: Module Federation
See also: Remote, Exposed module
- 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.
- Approach · single-spa →
More about Root config
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.
Source: Configuring single-spa
See also: single-spa, Lifecycle functions, Shell
- Runtime integration
- Combining teams' pieces in the browser while the page runs, so each piece can be released without rebuilding the shell.
- Lesson · What are micro frontends →Approach · Module Federation →
More about Runtime integration
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.
Source: Micro Frontends
See also: Build-time integration, Composition, Independent deploy
S
- Shellalso Host
- The app that owns the page layout and routing and loads or bundles the other teams' pieces into it.
- Approach · Module Federation →Lesson · What are micro frontends →
More about Shell
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.
Sources: Micro Frontends, Module Federation
See also: Remote, Composition
- single-spa
- A JavaScript framework that mounts and unmounts applications by route, even when they are written with different frameworks.
- Approach · single-spa →
More about single-spa
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.
Source: Getting Started with single-spa
See also: Root config, Lifecycle functions
- Singleton
- A shared dependency that Module Federation allows to load only once, so every piece on the page uses the same copy.
- Approach · Module Federation →
More about Singleton
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.
Source: ModuleFederationPlugin
See also: Shared dependency
- Slot
- A marked place on the shell's page where one team's piece is shown.
- Approach · Module Federation →Approach · Server and edge composition →
More about Slot
“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.
Sources: Micro Frontends, Module ngx_http_ssi_module, ESI Language Specification 1.0
See also: Shell, Composition
- Strangler fig pattern
- Replacing a legacy system gradually, moving one part at a time to new code until the old system can be removed.
- Lesson · Problems they solve →
More about Strangler fig pattern
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.
Sources: Strangler Fig, Micro Frontends
See also: Independent deploy, Runtime integration
V
- Vertical slice
- See Vertical split
- Vertical splitalso Vertical slice
- Dividing a product so that each team owns a whole feature or page from the user interface down, rather than one technical layer.
- Lesson · What are micro frontends →
More about Vertical split
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.
Sources: Micro Frontends, Micro Frontends – extending the microservice idea to frontend development, Micro-frontend Architecture, Micro-Frontends Splits - Vertical Split
See also: Micro frontend, Coupling
Sources
18 cited- Micro FrontendsCam Jackson · martinfowler.com
- Micro Frontends – extending the microservice idea to frontend developmentMichael Geers · micro-frontends.org
- Module Federationwebpack documentation
- ModuleFederationPluginwebpack documentation
- <iframe>: The Inline Frame elementMDN Web Docs
- Getting Started with single-spasingle-spa.js.org
- Enforce Module BoundariesNx documentation
- boundariesTurborepo documentation
- Modularization of a MonolithNatalia Venditto · microfrontend.dev
- Module Federation — Introductionmodule-federation.io
- Window: postMessage() methodMDN Web Docs
- Configuring single-spasingle-spa.js.org
- Micro-frontend and shared dependenciesNatalia Venditto · microfrontend.dev
- Module ngx_http_ssi_modulenginx.org
- ESI Language Specification 1.0Mark Tsimelzon et al. · W3C (Note)
- Strangler FigMartin Fowler · martinfowler.com
- Micro-frontend ArchitectureNatalia Venditto · microfrontend.dev
- Micro-Frontends Splits - Vertical SplitNatalia Venditto · microfrontend.dev