Modular Monolith vs Microservices

The debate between monolithic architectures and microservices is often clouded by ideological dogma. On one extreme, microservices are promoted as the sole modern paradigm; on the other, traditional monolithic architectures are dismissed as legacy technical debt.

In reality, the most effective enterprise architecture for the vast majority of business-critical systems is neither a distributed swarm of microservices nor an unmaintainable "spaghetti monolith." It is the Modular Monolith.

    SPAGHETTI MONOLITH             MODULAR MONOLITH                MICROSERVICES
+-------------------------+   +-------------------------+   +--------+     +--------+
| Tight cross-table joins |   | [Identity]  [Documents] |   | Auth   |     | Docs   |
| Mixed controllers/views |   |     |            |      |   | Service| <-> | Service|
| Circular dependencies   |   | [Billing]   [Workflows] |   +--------+     +--------+
| Single giant codebase   |   | Strict In-Memory APIs   |        |             |
| Uncontrolled mutations  |   | Unified DB Transactions |   +--------+     +--------+
+-------------------------+   +-------------------------+   | Billing| <-> | Workflow
                                                            +--------+     +--------+

Architectural Comparison#

What Defines a Modular Monolith?#

A modular monolith executes within a unified runtime environment and database connection, but enforces strict boundary rules:

1. Encapsulated Internal Schemas: Module tables are private to their module. Other modules cannot execute direct Eloquent joins or SQL queries across private tables.
2. Public Interface Contracts: Cross-module communication happens strictly via typed interface contracts (e.g., $billing->charge(...)) or dispatched domain events.
3. Independent Testability: Each module can be unit tested in isolation without spinning up network mocks or Docker containers.

// In a Modular Monolith: Cross-module interaction uses typed contracts
namespace App\Domain\Order;

use App\Domain\Inventory\Contracts\InventoryManagerInterface;
use App\Domain\Payment\Contracts\PaymentGatewayInterface;

final class ProcessOrderAction
{
    public function __construct(
        private InventoryManagerInterface $inventory,
        private PaymentGatewayInterface $payments
    ) {}

    public function execute(Order $order): void
    {
        // In-memory method invocation: 0 network latency, 100% type-safe
        $this->inventory->reserve($order->items);
        $this->payments->capture($order->paymentToken, $order->total);
    }
}

The Distributed Systems Tax#

When teams adopt microservices prematurely, they incur significant overhead before achieving scale benefits:

1. The Death of ACID Transactions#

In a modular monolith, if payment succeeds but order generation fails, a simple database rollback restores consistent state:

DB::transaction(function () use ($order) {
    $this->payments->capture($order);
    $this->orders->create($order);
});

In microservices, the same operation requires a complex Saga Pattern with compensating undo requests (refundPayment()), retry queues, and eventual consistency reconcilers.

2. Cascading Latency & Serialization#

Calling 5 microservices synchronously over HTTP/gRPC introduces network latency, JSON/protobuf marshalling, DNS lookups, and TLS overhead. An in-memory call takes < 0.01 ms; an HTTP service hop takes 2–10 ms.

When Microservices Are Truly Justified#

Microservices are appropriate when specific technical constraints cannot be satisfied within a unified runtime:

• Radically Divergent Scaling Profiles: e.g., video transcoding workers requiring GPU auto-scaling vs. CRUD admin APIs.
• Polyglot Technology Requirements: Machine learning models running in Python alongside high-throughput real-time telemetry ingestion in Go.
• Massive Organizational Scale: Hundreds of independent engineering teams requiring decoupled release cycles.

For 95% of business applications, a Modular Monolith built on a robust platform like Alegor delivers superior performance, lower infrastructure costs, and faster iteration speed.

Next: When to Split a System into Microservices or explore Alegor Platform Architecture.