The Microservices Trap: Why Your Team Needs a Modular Monolith
Startups copy Big Tech playbook blindly. Team of five engineers builds twelve microservices before finding product-market fit. Result: catastrophe. Engineering velocity hits wall. Engineers spend days debugging Kubernetes manifests, distributed trace failures, cross-service auth tokens. Zero features ship.
At Kreasi Kita, diagnosis simple: microservices trade in-memory function calls for unpredictable network calls. Teams replace simple code complexity with brutal infrastructure, deployment, operational overhead.
Scale problems of Netflix not your problems. Architecture must match team size, budget, domain maturity. Modular monolith delivers high performance, clean boundaries, rapid iteration. Distributed microservices deliver cloud bills, latency penalties, distributed state bugs.
+-----------------------------------------------------------+
| THE OPERATIONAL FORK |
+-----------------------------------------------------------+
| MODULAR MONOLITH | MICROSERVICES MESH |
| Function call: ~10-50ns | HTTP/gRPC call: ~2-15ms |
| ACID transaction: atomic | 2PC/Saga: eventual consistency|
| Single deploy pipeline | N pipelines, version matrices |
| One Postgres instance | N databases, sync drift |
| Single binary / worker | Kubernetes, Istio, Consul |
+-----------------------------------------------------------+
False Promise of Microservice Hype
Tech marketing sells microservices as silver bullet. Claims: infinite scale, independent deployments, total technology freedom. Reality different.
Technology freedom inside small team breeds chaos. One engineer writes Go service. Second writes Python service. Third writes NestJS service. Now team maintains three runtime environments, three dependency scan workflows, three testing strategies. Engineer leaves company. Remaining engineers cannot maintain unfamiliar stack.
Independent deployment advantage also illusion. Early product development alters domain boundaries weekly. New checkout flow requires simultaneous changes across CartService, BillingService, InventoryService, NotificationService. Team coordinates multi-repo pull requests, sequences deploys across staging environments, prays schema migrations do not drift. Distributed architecture makes refactoring impossible. Monolith makes refactoring single safe IDE command.
Architectural Comparison: Modular Monolith vs Microservices
Evaluating modular monolith vs microservices requires measurement of mechanical symphonies, operations, runtime latency.
| Architectural Dimension | Modular Monolith (Postgres + Laravel/Next.js) | Microservices Mesh (Docker + K8s + gRPC) |
|---|---|---|
| Invocation Latency | Sub-microsecond (In-memory stack) | 2ms - 30ms (TCP, TLS, serialization) |
| Data Consistency | Immediate ACID guarantees | Eventual consistency, Saga orchestration |
| Infra Footprint | Single VPS ($40/mo - $300/mo) | Managed K8s control plane + nodes ($500+/mo) |
| Observability | Single runtime log, basic APM | Distributed tracing (OpenTelemetry, Jaeger) |
| Deployment Time | 2-5 minutes (single artifact) | 20-45 minutes (mesh synchronization) |
| Failure Modes | Process crash, DB contention | Network split, cascading timeout, partial write |
IN-MEMORY CALL (Modular Monolith):
OrderService ---> [In-Memory Bus] ---> InventoryService (0.00005 ms)
Single DB Transaction: [Order: CREATED | Inventory: DECREMENTED] -> COMMIT
DISTRIBUTED CALL (Microservices):
OrderService ---Network (JSON/gRPC)---> InventoryService (15 ms)
| |
|-- (Failure / Timeout) |-- Writes to Inventory DB
v v
Order DB: FAILED Inventory DB: DECREMENTED
Result: Split-brain state. Manual reconciliation required.
Technical Tax: Distributed Transactions and Consistency
Data integrity kills microservice architectures. Single relational database gives team ACID transactions for free. Distributed systems demand manual transaction management.
Anti-Pattern: Distributed Dual-Write
Service updates internal database, publishes event to message broker:
// Broken: Dual-write without outbox pattern
async function completeCheckout(orderId: string, paymentDetails: PaymentInfo) {
const order = await orderRepo.markAsPaid(orderId);
// Network blip here causes split-brain state
// DB committed, broker never receives event
await kafkaProducer.send({
topic: 'orders.completed',
messages: [{ key: orderId, value: JSON.stringify(order) }]
});
return order;
}
Fixing dual-write demands Transactional Outbox Pattern:
- Write order change to DB.
- Write event payload to
outboxtable inside same ACID transaction. - Run background polling process or parse DB Write-Ahead Log (WAL) via Debezium.
- Push event to Kafka.
- Record publication status.
Team built five infrastructure components just to safely update one database record.
Contrast: Atomic Monolith Transaction
Single database instance provides absolute safety via single transaction boundary:
// Modular Monolith: Native atomic safety
import { db } from '@/infrastructure/database';
export async function completeCheckout(orderId: string, paymentDetails: PaymentInfo) {
return await db.transaction(async (trx) => {
const order = await trx('orders')
.where({ id: orderId })
.update({ status: 'PAID' })
.returning('*');
await trx('inventory')
.where({ sku: order.sku })
.decrement('stock_quantity', order.quantity);
await trx('audit_logs').insert({
action: 'ORDER_COMPLETED',
entity_id: orderId,
timestamp: new Date()
});
return order;
});
}
Zero event brokers. Zero network retries. Zero reconciliation workers. Database engine handles locking, atomicity, crash recovery.
Concrete Implementation: Domain Boundaries Inside Single Runtime
Modular monolith not messy spaghetti codebase. Requires strict boundaries between business domains. Modular monolith enforces logical separation via package structures, explicit public interfaces, module-level access controls.
Directory Architecture
Example: High-throughput e-commerce core built in TypeScript/Next.js or Laravel:
src/
├── core/ # Shared platform primitives
│ ├── database/ # Shared DB connection pool
│ ├── logger/
│ └── events/ # Internal event dispatcher
├── modules/
│ ├── identity/ # User auth, roles, profiles
│ │ ├── internal/ # Private implementation details
│ │ │ ├── services/
│ │ │ └── models/
│ │ └── index.ts # STRICT public module API exports
│ ├── billing/ # Invoices, subscriptions, webhooks
│ │ ├── internal/
│ │ └── index.ts
│ └── catalog/ # Products, inventory, variants
│ ├── internal/
│ └── index.ts
└── app/ # HTTP / API controllers routing requests
Enforcing Module Encapsulation
Direct cross-module database queries strictly forbidden. Billing module cannot query users table directly. Must invoke public API of Identity module:
// modules/identity/index.ts
// Explicit public API contract
export interface UserIdentityDTO {
id: string;
email: string;
isActive: boolean;
}
export class IdentityModule {
static async getActiveUser(userId: string): Promise<UserIdentityDTO> {
const user = await UserRepository.findById(userId);
if (!user || !user.isActive) {
throw new Error('User not found or inactive');
}
return {
id: user.id,
email: user.email,
isActive: user.isActive
};
}
}
Billing module consumes interface cleanly:
// modules/billing/internal/services/invoice.service.ts
import { IdentityModule } from '@/modules/identity';
export class InvoiceService {
async generateInvoice(userId: string, amount: number) {
// Uses contract, zero direct coupling to Identity internal DB logic
const user = await IdentityModule.getActiveUser(userId);
return Database('invoices').insert({
user_id: user.id,
user_email: user.email,
amount: amount,
created_at: new Date()
});
}
}
Enforce boundaries using build tools. Linting rule inside eslint.config.js blocks illegal imports:
// Disallow imports into module internals from external modules
{
rules: {
'no-restricted-imports': ['error', {
patterns: [{
group: ['@/modules/*/internal/**'],
message: 'Direct access to module internal code forbidden. Import via public module index.'
}]
}]
}
}
Shared Database with Logical Isolation
Teams often assume microservices mandatory for clear schemas. False. Use logical separation within single PostgreSQL instance:
-- Create distinct logical namespaces
CREATE SCHEMA identity_module;
CREATE SCHEMA billing_module;
CREATE SCHEMA catalog_module;
-- Define tables within domain namespaces
CREATE TABLE identity_module.users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
email TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE billing_module.invoices (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL, -- Logical reference, no hard cross-schema FK constraint
amount_cents INT NOT NULL,
status TEXT NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Separate Postgres roles prevent accidental cross-schema pollution
CREATE ROLE billing_service;
GRANT USAGE ON SCHEMA billing_module TO billing_service;
GRANT ALL ON ALL TABLES IN SCHEMA billing_module TO billing_service;
Logical schemas guarantee clean boundaries. Database engines scale this pattern to hundreds of gigabytes, millions of records without operational overhead of multi-instance clusters.
When Extraction Actually Makes Sense
Monolith first. Always. Extract microservice only under extreme, measurable conditions.
Legitimate extraction criteria:
- Compute Disparity: Core application handles standard CRUD operations (I/O bound). Video processing or machine learning model demands dedicated GPU clusters (CPU/GPU bound). Extract media processor.
- Distinct Scaling Ratios: Public tracking pixel endpoint receives 500,000 requests per second. Admin panel receives 10 requests per minute. Keeping ingest endpoint inside monolith exhausts connection pool. Extract telemetry ingest engine to lightweight Go or Rust service.
- Regulatory / Compliance Isolation: Strict PCI-DSS or HIPAA controls require narrow audit scope. Extract payment tokenization system into isolated VPC to drop compliance scope for remainder of codebase.
Engineering team size never justification for microservices until company exceeds 100+ engineers with conflicting deploy schedules. Amazon and Shopify run monolithic platforms processing billions of dollars. Your app can run on monolith.
Migration Path: Reversing Microservices Trap
Consolidate distributed microservices back into single repository using systematic process:
For critical production infrastructure migrations, execute steps in strict sequence to avoid downtime and data loss:
- Create new unified repository containing target framework (Next.js, Laravel, Go, or Rails).
- Establish domain directories matching current microservice responsibilities.
- Migrate codebases sequentially into internal directories.
- Point external service HTTP calls to direct internal module interfaces.
- Consolidate separate operational databases into single PostgreSQL instance using logical schemas.
- Decommission intermediate Docker containers, API gateways, Kubernetes ingress controllers.
- Terminate distributed tracing clusters. Run system via simple vertical autoscaling.
Ship Product, Not Cluster Config
Engineering exists to produce business value. Microservices architecture shifts engineering effort away from core product toward distributed systems plumbing.
Keep architecture simple:
- Single modular monolith.
- Domain boundaries enforced by compilation and lint rules.
- Single robust PostgreSQL database.
- Atomic ACID transactions.
- Zero distributed state synchronization bugs.
Extract services when production profiling numbers demand isolation, not before.
Designing mission-critical platforms, rescuing sprawling microservice architectures, or building performant modern backends requires seasoned engineering craft. Build pragmatic, maintainable architecture with Kreasi Kita.
ABOUTPROJECTS