The longstanding discourse surrounding software architecture has primarily revolved around two opposing models: monoliths and microservices. The merits of each model have been debated for decades, as each presents unique benefits and drawbacks. However, a new, powerful concept is emerging, one that blends the composability and scalability of microservices with the performance and simplicity of monoliths: the microlith.

This idea isn't entirely new. Discussions around microliths have surfaced before, such as in a detailed exploration by New Zealand IT here and in Oracle's Java Magazine here. Yet, what is especially exciting today is the evolution of the microlithic concepts to meet modern challenges of latency-sensitive, data-intensive applications.

‍

What Is a Microlith?

A microlith is a software architectural model that embodies the best traits of monoliths and microservices. It's small, self-contained, and highly performant — but crucially, it still preserves the deployment flexibility and modular thinking that made microservices popular.

Broadly, there are two interpretations of microlith architecture:

1. Horizontal Microlith — An application where services are horizontally integrated in the application space but still rely on an external, often separate, database or cache layer.
2. Vertical Microlith — A vertically integrated application that bundles application logic, database, cache, and APIs all into a single deployable unit aimed at achieving a specific purpose.

This article focuses on the second model: vertically integrated microliths. In many ways, this architecture represents the future for organizations needing low-latency, high-throughput applications that remain simple to manage and deploy.

‍

Why Vertically Integrated Microliths?

In a traditional microservices setup, each service communicates over the network, introducing latency, complexity, and security concerns. By contrast, a vertically integrated microlith eliminates those issues. Services communicate in "function space" within the same runtime rather than over the network.

Key Benefits:

• Low Latency: No network hops between your application, cache, and database.
• Higher Security: Eliminates risks like man-in-the-middle attacks by removing network calls altogether.
• Lower Total Cost of Ownership (TCO): Less infrastructure to manage, fewer points of failure, simpler deployment models.
• Composability: Easily compose multiple microliths into a larger, scalable system without the brittle complexity of microservices.
• Less Code: With a fully integrated stack, you can eliminate much of the connective "glue code" that often bloats microservices — think 500 lines reduced to 30-50 lines.

‍

Microliths in Action: Use Cases

Imagine you are building an application that must deliver ultra-low-latency responses to user queries against massive datasets. Think e-commerce product pages that need to be performance optimized for SEO, real-time sports betting platforms, or even multiplayer gaming backends.

In a traditional microservices model, every user interaction would trigger a cascade of API calls: front-end to gateway, gateway to service, service to database, database back to service, service to cache, and so on.

With a vertically integrated microlith:

• The application layer, cache, and database all reside within the same runtime.
• A user's request traverses in-memory function calls.
• Persistence and replication is handled with native functionality of the microlith technology (like Harper does).

The result? Milliseconds saved at every turn, happier users, less operational complexity and even high revenue.

‍

Scaling Microliths

A common misconception is that vertically integrated microliths don't scale well. Not true.

Scaling vertically integrated microliths is straightforward:

• Deploy multiple microliths based on application domains or resource needs.
• Set up real-time data synchronization between microlith servers so all have a persistence layer, allowing them to operate independently when responding to clients. 

To achieve industry-leading speed for product pages, implement a geographically distributed network of microliths. Each microlith must be capable of independently handling page requests. This requires the microlith to contain an API that can identify the requested page, retrieve the pre-rendered product page from memory, and return it to the client.

In the real world, large-scale deployments have seen hundreds of nodes operating in microlith clusters. Each node a fully self-sufficient unit, coordinating data replication intelligently. 

‍

Composability: The Secret Weapon

One of the most understated advantages of vertically integrated microliths is composability.

Each microlith can be seen as a "Lego brick" — a self-contained unit that you can combine with others to create complex systems without worrying about dependency hell or service orchestration nightmares.

• Need a new feature? Spin up a new microlith.
• Need to update a component? Swap it out with zero downtime.
• Need to scale globally? Replicate microliths to edge locations with replication turned on.

Unlike monoliths, microliths allow granular, targeted upgrades and deployments, but unlike microservices, they don't fragment your architecture into an unmanageable mess.

‍

Write Less Code, Build More Value

Jaxon Repp, Field CTO at Harper, put it best: with a vertically integrated microlith model, production-grade applications can be built with under 100 lines of code.

How?

• No boilerplate database connection logic.
• No complex caching layers to manage.
• No sprawling API gateway configurations.

Instead, developers focus purely on business logic and proper data indexing. This not only accelerates development cycles but also dramatically reduces the likelihood of bugs creeping in through poorly connected infrastructure code.

The beauty of microliths is in their simplicity. They let you get back to solving real problems, rather than wrestling with the plumbing.

‍

Getting Started

If you're curious about putting microliths into action, the best way to start is with a small project or demo. Build something latency-sensitive, like a consolidated redirect system or a dynamic e-commerce website with personalization.

See for yourself how much code you don't have to write.

And if you're ready to dive deeper, check out Harper — a platform built from the ground up to enable vertically integrated microlith architectures. Harper combines database, cache, APIs, and programmable application logic in one deployable unit, helping you achieve the promise of microliths today.

Learn more and get started with Harper here.

‍