The story started when I started working for a company in Canada. Shortly after joining, I was assigned a task to build a microservice.
The company had excellent documentation, clear architectural guidelines, and a well-structured codebase.
I implemented the service, integrated it with the API Gateway using Ocelot, and prepared for demo day.
The demo went incredibly well. For a moment, I felt like a hero. 😄
Of course, my pull request wasn't perfect. There were review comments, SonarQube wasn't happy with some of my naming conventions, and a few code smells needed attention.
But I genuinely enjoyed the experience.
I learned a lot about RabbitMQ, Ocelot routing, API gateways, rate limiting, and how distributed services communicate.
I fell in love with microservices. Then I joined a company in Romania.
Different company. Different architecture.
This time, the backend was a modular monolith, and the frontend was an Angular monorepo.
The codebase was massive. Understanding the entire application wasn't easy, especially as someone joining an established project.
And I started missing microservices.
I missed those smaller, independently understandable services. I missed the feeling of working on one focused component without navigating a huge codebase.
At that point, I genuinely believed microservices were the better architectural choice.
All of this happened before the AI coding era.
Fast-forward a few years.
I had become much more experienced with Angular, .NET, design patterns, and software architecture.
I joined another company in Cyprus.
We had a large, complex project, and this time I had the opportunity to influence its architecture.
I proposed microservices. The proposal was approved and we started building.
Initially, everything felt familiar, easy and seamless
Small services. Clear responsibilities. Independent components.
Exactly what I had enjoyed years earlier.
Then reality arrived.
The customer kept changing requirements.
What looked like a simple change started affecting multiple services. Features that were supposed to be straightforward required coordination across service boundaries.
And things became increasingly complicated.
To make matters worse, we were building a multi-tenant platform.
Different tenants had different expectations, requirements kept evolving, and our architecture was becoming an obstacle rather than an advantage.
The services were individually simple but the system was not.
We spent considerable time going back and forth, fixing issues, coordinating changes, and trying to stabilize the platform.
Eventually, we got things reasonably stable.
But the architectural overhead wasn't going away. Then one day, our senior architect joined a call with me.
We discussed the situation and came to a difficult conclusion.
We needed to make a bold architectural decision: migrate from microservices to a modular monolith.
And we did it, In approximately two weeks, we migrated the architecture. He was amazed how I handled the heavy lifting.
The result?
The team was happy. The work was appreciated. Everyone started smiling again.
But I think the biggest smile was mine. It should be right?😄
Because I knew exactly how much complexity we had just eliminated.
No more running multiple services locally just to work on a feature.
No need to spin up RabbitMQ, Azure Service Bus, and other infrastructure dependencies for routine development.
No unnecessary service-to-service communication.
One deployable application. One database. Clear module boundaries.
Upgrades became easier. Development became simpler.
And continuous delivery became much less painful.
No drama. Just peace.
There's another part of this story worth mentioning.
For years, I had been reading Dr. @mjovanovictech LinkedIn posts and his satureday morning newsletters.
He consistently shared practical ideas about modular monoliths, clean architecture, and making architectural decisions based on real engineering needs.