Skip to main content

Zero-Cliff UI: The Future of Multi-Package Composition

· 4 min read
Revant Nandgaonkar
Revant Nandgaonkar
Maintainer of Framework M

In enterprise software, the transition from a "local prototype" to a "distributed global deployment" is usually where things get messy. At Framework M, we’ve spent a lot of time thinking about how to make that transition invisible. We call it Zero-Cliff UI Composition.

The Multi-Package Dilemma​

If you are building a large business suite (like our Business M), you are likely working in a monorepo. This is great for developer velocity—one place for all your code, shared CI, and easy cross-module refactors.

But as the complexity grows, you hit two distinct walls:

  1. The Scaling Tax (Enterprise): If one team updates a single component in the WMS module, you shouldn't have to rebuild, redeploy, and force a redownload of the entire multi-megabyte suite for every user—especially those who only ever use Finance.
  2. The Stability Wall (Indie): In a "0-cliff" workflow, you want to build one app, make it stable, and then forget about it while you "climb" to the next. You shouldn't have to worry about breaking your foundation while iterating on the periphery.

These walls exist because current architectures usually force a binary choice:

  • Build-time composition (Monorepo) is great for DX but fails for independent release cycles.
  • Runtime composition (Micro-frontends/MFE) is great for scaling but usually introduces a massive "tax" in infrastructure complexity.

Enter the Zero-Cliff Philosophy​

We designed the Framework M UI composition to be progressive. Your code shouldn't care how it’s being deployed. Whether you are running a single pnpm workspace on your laptop or serving a globally distributed enterprise suite via CDN, the frontend code remains exactly the same.

We achieved this by defining 5 levels of deployment:

  1. L1: Monorepo Indie – Local dev with build-time imports. Fast and simple.
  2. L2: Monorepo Docker – Production builds where everything is bundled together.
  3. L3: Distributed (PyPI) – The "Unit of Truth" – Plugins are installed as Python wheels. This is the "Zero-Config" sweet spot where stable modules stay stable, and the Python package remains the immutable source of truth for the browser.
  4. L4: Scaled Delivery – Nginx/Proxies serve assets extracted from the plugin wheels.
  5. L5: Global Enterprise (CDN) – CI/CD syncs the static/mfe assets from the same plugin wheels to a CDN.

By making the Python Package the universal unit of distribution, we ensure that your app—whether it’s a simple plugin or a complex suite—can be deployed anywhere, any how, without losing its identity.

The Modular Monolith Advantage​

Framework M is optimized for Modular Monoliths. We believe this is the superior choice for most business logic—providing type safety, transaction integrity, and simple deployments.

For specialized high-throughput tasks, we simply use the right tool for the job. Services like book-keeper and stock-keeper provide high-performance, headless endpoints, while Framework M remains the unified hub for the business suite and the UI.

What it doesn't (and won't) do:​

We are explicitly not building a general-purpose service aggregator for the UI.

  • No Network Discovery: The Discovery API scans the current Python environment. It won't try to crawl your network to find external services.
  • No Fragment Bloat: Headless services like stock-keeper or book-keeper stay headless. They don't need to—and won't—contribute UI fragments to the main dashboard.

API-First Flexibility​

Because every Framework M app is API-first, you always have a choice:

  • Build Custom Frontends: Keep the built-in dashboard for your staff while building a separate, bespoke consumer frontend.
  • Pure Headless: For advanced cases, you can eject the UI entirely and use Framework M as a high-performance headless engine.

Summary​

By focusing on a Modular Monolith with specialized backend engines where they make sense, we provide an "enterprise-scale" experience without the infrastructure complexity at the UI layer. You start with a single package, grow into a multi-repo suite, and scale to global CDN delivery—all without changing a single line of your React components.

That’s Zero-Cliff UI. It’s built to scale with your business.