We love distributed systems because they make us feel like enterprise architects, even when we are building CRUD apps for three hundred daily active users.
Every time a junior engineer suggests splitting our monolith into a dozen microservices, they talk about fault tolerance and independent deployments. What they actually build is a distributed monolith with network latency, asynchronous race conditions, and a deployment pipeline that requires three people and a ritual sacrifice to update a button color.
Service-oriented architecture is a solution to a very specific organizational problem. That problem is having thousands of engineers working in the same codebase, stepping on each other's toes, and grinding feature velocity to zero due to merge conflicts. If your team fits in a single Slack channel, you don't have an organizational scaling problem. You have a code organization problem, and microservices won't save you from bad modularity.
Take authentication. In a monolithic SaaS application, checking a user session is a function call. It accesses shared memory, executes in microseconds, and fails gracefully because the database connection is right there. The moment you move to services, that single function call transforms into an HTTP request or a gRPC stub over a private network. Now you have to worry about timeouts, circuit breakers, retry logic, and distributed tracing just to figure out who is clicking your dashboard.
# What we think we are building
class OrderService:
def create_order(self, cart_id):
user = auth_client.get_user_by_cart(cart_id)
inventory = inventory_client.reserve(cart_id)
return database.commit(user, inventory)
# What we actually have to write to handle network partitions
class RobustOrderService:
def create_order(self, cart_id, retry_count=3):
try:
user = self._call_auth_with_timeout(cart_id)
except NetworkTimeout:
if retry_count > 0:
return self.create_order(cart_id, retry_count - 1)
raise DistributedSystemFailure("Auth service is down again")
When you add AI integrations or local LLM wrappers into a distributed stack, the complexity curve goes vertical. Debugging a hallucinated token stream across three different microservices is a masterclass in frustration. You end up writing more infrastructure code to glue your services together than actual business logic that brings revenue.
Modular monoliths give you the best of both worlds. You enforce strict boundaries through directory structures and package visibility rules, keeping your domain logic isolated without paying the operational tax of network boundaries. You can still scale your database reads, you can still optimize hot code paths, and you can still refactor with a single click in your IDE.
Next time someone proposes breaking your SaaS into smaller services, ask them what specific business metric will improve by introducing a network layer between your objects. If the answer is anything other than team organizational scale, keep your code in one repository.
