Phase 1: A Portal Built Beside the Old System
We didn't start with a big-bang rewrite. We began with a new .NET and Angular application running beside the existing one, on the same database and the same user accounts, so nothing in the live system had to change.
Our design team took it from UX wireframes of every user flow to a full UI design in Figma. The result is a portal where administrators build a tree of report pages, decide which roles see each one, and embed a Power BI report per page, filtered so every client and supplier sees only their own data. Certificates of Analysis, non-conformances, corrective actions, testing notices, and invoices each got their own views, with PDF and CSV export.
Clients got a modern window into their data. We got a detailed map of the lab's business logic, which shaped everything that followed.
Phase 2: The Full Rebuild, With Parity as a Goal
The second phase rebuilds the platform itself on the latest .NET and Angular, with MS SQL Server behind it and an architecture brought up to current standards. The goals were written down from the start: a modern stack, no bottlenecks, better performance, full functional parity, and all existing data available and working. Parity and data are where rewrites usually fail, so they're requirements, not hopes.
The easiest way to see what the rebuild covers is to follow a single product through the lab.
It starts with a specification. The lab defines what to test, how many samples to take, and what counts as a pass, building it from reusable pieces so the same product can be held to different standards depending on where it's made. Every change is versioned and can be rolled back, because a result is only as trustworthy as the specification behind it.
From there, the platform schedules the testing. Recurring testing requests go out to suppliers automatically, the system tracks who received and read them, and it chases the ones that go quiet. In the lab, technicians record every step and every measurement against a full audit trail, so anyone can see who did what, and when.
When a result comes back out of bounds, nobody has to spot it by hand. A rule engine raises a quality issue on its own, with the right severity and the failing values attached, and opens a ticket in Freshdesk, where the support team handles the conversation. Status updates flow back into the platform automatically, so the issue and the ticket never drift apart. When everything passes, a certificate is generated for the client to review and publish.
Finally, the work turns into money. Completed tests generate their own invoices, scheduled billing runs retry if anything fails, and payments are matched back to the invoice they settle. Throughout it all, every client, supplier, and facility sees exactly what their role allows and nothing more.
From Several Minutes to Several Seconds
Performance was a priority from the start, not something saved for the end. By finding and removing the bottlenecks behind it, we brought loading of the main dashboard down from several minutes to several seconds.
That's a change users feel on the first day. The screen people open most often stops being a coffee break, and the time saved adds up across every user, every day.