Migrating to Microservices: Lessons from Rebuilding CalcMenu Cloud
How I led the rebuild of a slow, buggy legacy platform into a microservice-based one without interrupting customer service, and the unglamorous work that made it possible.
From 2021 to 2023 I led the rebuild of CalcMenu Cloud at CalcMenu Philippines. I worked on it alone at first and later led a team of four developers. The goal was to replace a slow, buggy legacy system that ran outdated, vulnerable software with a microservice-based platform built with Docker and CI/CD. Clients depended on the old system every day, so the rebuild could not interrupt their service.
It didn’t. We replaced the old system without a break in customer service, and clients ended up on a faster, more reliable platform. That wasn’t down to clever architecture. It came from being careful about risk and strict about scope.
Why we rebuilt
The old platform was slow and buggy. It ran outdated software versions with known vulnerabilities and couldn’t integrate with other systems, so it couldn’t support where the business was heading. Clients still relied on it every day, though.
That ruled out starting over and switching everyone at once. A big-bang rewrite was too risky for a system people used daily. We needed a gradual path.
Choosing the stack
We built on Angular for the front end, ASP.NET and Python services on the back end, and SQL Server for data, with Docker and CI/CD for deployment and hosting on Azure and AWS. None of it was new or exciting, and that was deliberate.
I’ve seen projects struggle because someone chose a trendy framework nobody on the team had shipped with. A well-understood stack lets you ship sooner with less risk. Because I started the rebuild alone, that mattered even more, and when the team of four joined they could build on the same foundation.
Running both systems in parallel
This is what made the project work. The old system kept running while we built the new one, and clients moved across gradually. In the end the two systems ran side by side for about six months before the last client moved over. There was never a single cutover date where everything had to go right at once.
We started with the core features most users touch every day. We didn’t aim for full feature parity at first. The point was to get the essentials in front of people, get feedback and iterate.
Next came data migration. We started with read-only migrations: a client’s data was copied into the new system so they could verify it, while they kept working in the old one. Seeing their own data in the new platform before committing gave clients confidence in the move.
Only then did we cut clients over, wave by wave rather than all at once. Around 27 clients made the move from the old system to the new one, and each wave showed us something that made the next one smoother.
What worked
We put an API gateway in front of everything. It gave the front end one entry point, so it never had to keep track of a long list of service URLs.
Services were organized by business domain rather than by technical layer. Each service owned one area of the business, instead of the same feature being split across separate services for things like data access and validation. That kept the design simpler and cut down on calls between services.
Long-running tasks went through RabbitMQ message queues. Services didn’t have to block waiting on each other, and that work could be scaled separately from the rest of the system.
On the process side, we shipped releases with Agile/Scrum, working across Asia and Europe.
Lessons I’d pass on
Expect the old data to hide things. One real problem for us was dormant data. When users deleted records in the old system, its developers had never properly cleaned them up, so leftover data was still sitting in the database. During migration it surfaced again, and clients were confused to see records they thought were long gone. We got explicit consent from each client before touching their data, and in some cases we worked with the client’s technical team to make sure nothing was lost. Once it was clear the leftover records were garbage, we deleted them and kept a backup. Reviewing what the old system actually stores, not just what it shows, saves a lot of explaining later.
Check client environments early. Some of our clients were running old devices that didn’t support the new system very well, and we had to account for that during cutover. Finding out what devices clients actually use before you plan their move is much better than discovering it during the move.
Start with fewer, larger services, and split one only when there’s a real reason, such as different scaling needs or team ownership. Set up centralized logging and tracing from the start, too. Following a request across several services without it is very hard.
The outcome
The new platform closed the known vulnerabilities in the old one and supports integrations the old system never could. Every client was moved over without their service being interrupted.
When microservices make sense
They’re worth it when you have clear business domains, parts of the system that need to scale independently, and enough engineers to own separate services. If your team is very small, your domain boundaries are unclear, or you’re still working out what the product is, build a monolith.
For us, what mattered most was running both systems in parallel, starting with core features instead of chasing parity, getting feedback early, and letting clients verify their data before they moved. The architecture patterns mattered less than planning, communication and the unglamorous infrastructure work.
Comments
Loading comments