Moving off an old system can feel like a gamble. In this case, it paid off in a big way. We helped a growing manufacturer move the core logic of their system from Visual Basic for Applications (VBA) to .NET. The new version ran up to 900% faster, depending on the job, and the team estimated it would save about 1,361 hours a year.
Here is how it happened, and what other manufacturers can take from it.
Why the old system had to change
The company had grown quickly, and its operation had outgrown the VBA macros that ran it. Three problems kept coming up:
- It was slow. Processing work took long enough that people planned their day around waiting for it.
- It couldn’t scale. More orders meant more waiting, and the gap got worse every month.
- It was hard to change. Adding a feature meant working inside fragile code that few people understood.
The business needed a system that could handle more volume today and keep growing with them. Moving to .NET addressed all three problems at once.
Step 1: Understand the old code first
Before writing anything new, we spent several weeks studying the existing VBA. The goal was to understand exactly what it did, including the rules nobody had written down. Every migration we’ve done has been different, and this phase is what keeps surprises from showing up later.
We found two big things. First, much of the code ran one step at a time, so large jobs had to wait in line. Second, several of those steps could safely run in parallel. That second finding became the biggest source of the speed gains.
Step 2: Migrate in manageable pieces
Instead of rewriting everything at once, we broke the VBA logic into smaller parts and moved them to .NET one at a time. This made each piece easier to build and test, and it kept the business running normally throughout the project. Nobody had to stop work for a big cutover.
Step 3: Prove it matches the old system
Each new piece was tested against the original to confirm it produced the same results. We worked closely with the client during this phase so the new system matched how they actually worked, not just how the old code said they worked.
The results
When the first phase was complete, we ran the old and new systems side by side on the same data. The new version was up to 900% faster, with most jobs between 300% and 900% faster depending on the input. Based on how often the team ran those jobs, they estimated about 1,361 hours saved per year.
The speed came from using what modern .NET does well:
- Running work in parallel instead of one step at a time
- Better memory management for large jobs
- Just-in-time compilation, which turns code into fast machine instructions as it runs
- Replacing slow logic with more efficient approaches
What other manufacturers can take from this
A slow legacy system isn’t just an annoyance. It is lost hours every day, and that cost grows as the business grows. The lesson from this project is that modernizing doesn’t have to be risky when you do it in the right order: understand the system first, move it in pieces, and prove each piece before moving on.
You can read more about this kind of work on our legacy system modernization page, or see a related project in our field service and ERP modernization case study.
