Microkernel Architecture

Every new feature means growing the core system itself

A monolithic core that directly contains every feature — every file format it can export, every integration it supports — grows without bound, and shipping a fix for one feature means redeploying (and re-testing) the entire application, including features that had nothing to do with the change.

A small core, a registry, and independent plug-ins

The core system implements only the minimal mechanics — a plug-in registry and the ability to invoke a plug-in at defined extension points. Each feature is a separate plug-in implementing an agreed interface, registered into the core. Plug-ins can be added, removed, or updated independently of the core and each other.

A minimal core hosting independently registered export plug-ins

The core doesn't know PDF or CSV export exist — it only knows the plug-in interface every export plug-in agrees to implement.

// Core system: knows only the plug-in contract, nothing feature-specific.
class Core {
  #plugins = new Map();
  register(name, plugin) { this.#plugins.set(name, plugin); }
  export(name, data) {
    const plugin = this.#plugins.get(name);
    if (!plugin) throw new Error(`no plug-in registered for "${name}"`);
    return plugin.export(data);
  }
}

// Plug-ins: each independently implements the same interface.
const pdfPlugin = { export: (data) => `%PDF-1.4 ... ${JSON.stringify(data)}` };
const csvPlugin = { export: (data) => Object.values(data).join(",") };

const core = new Core();
core.register("pdf", pdfPlugin);
core.register("csv", csvPlugin);

console.log(core.export("csv", { name: "Alex", age: 30 }));
// Adding a new format later: one new plug-in, zero core changes.

Trade-offs

• Features ship and version independently — Each plug-in can be added, updated, or removed without touching the core or other plug-ins.
• Small, stable core — The core's surface area stays minimal, so it changes rarely and is easier to keep reliable.
• Plug-in interface design is the hard part — A too-narrow contract can't support future plug-ins' needs; a too-broad one starts leaking implementation details back into the core.