Agfa Gevaert.

A team with no frontend practice, building software that controls the production of photographic film rolls worth 100k each. In one year we defined the entire development strategy from scratch and turned a team of juniors into autonomous engineers who now ship 10 MES applications on their own.

The Situation

Agfa Gevaert’s MES (Manufacturing Execution System) team builds the software that runs their manufacturing floor. 10 applications covering everything from production recipes to quality control, for products where a single roll of photographic film can be worth over 100k.

The team’s original developers had been hired 30 years ago. They were retiring or had already left. The new generation was a team of three junior engineers and two seniors, eager to learn but with no frontend experience between them. There was no established frontend practice, no shared development standards, no structured UX process, and no one with the specialized frontend expertise to guide them.

Existing applications relied on a closed-source Blazor UI library costing 20k per year in licensing. It locked the team into rigid design patterns, hid implementation behind packages, and made customization painful. The team was paying for a tool that was slowing them down.

Agfa recognized they needed specialized help to build a frontend capability that would outlast any single person. They brought us in for one year.

What We Did

Architecture & Modernization

We didn’t just define a strategy. We designed the UIs, built the architecture, wrote the code, set up the pipelines, and mentored the team, all while documenting everything as an educational framework they could follow, internalize, and replicate on their own.

UX/UI design. We designed the user interfaces and optimized workflows for MES applications, starting from user research: personas, journey mapping, wireframing, and iterative validation with the people on the factory floor. The goal was to stop building interfaces that mirror developer mental models and start building for actual users. The process we introduced gave the team a repeatable framework for scoping any new application.

API-first architecture. We decoupled frontend and backend entirely, introducing OpenAPI specifications as the contract between the two. Frontend and backend could now develop in parallel. The spec became the single source of truth, with auto-generated API clients and published documentation.

Component library and design system. We replaced the 20k/year third-party library with a custom-built component library owned entirely by the team. No more black-box packages. We documented components in Storybook, versioned them, and distributed them through automated CI/CD pipelines. The library was designed to grow organically as new components emerged from project work.

Project templates and tooling. We built .NET templates that scaffold a complete new application with a single CLI command: authentication, state management, and the component library included out of the box. What used to take days of manual setup now takes one command and a few minutes.

Team Building & Leadership

Three junior engineers with no frontend experience needed to own this system within a year. Every technical decision was made with that deadline in mind.

We paired with the juniors daily. Code reviews weren’t gatekeeping exercises; they were structured mentoring sessions where every piece of feedback explained the why, not just the what. We chose patterns not for their technical elegance, but for how well a junior developer six months in could understand and maintain them. The strategy document we delivered wasn’t just a reference. It was a curriculum: a complete frontend development playbook the team could follow, internalize, and teach to the next person who joins.

The goal was never to make the team dependent on us. It was to make us unnecessary.

The Result

One year. That’s what it took to go from no frontend practice to a team that ships independently.

The three junior engineers who had never built a frontend now scope, design, and build MES applications on their own. 10 applications run on the architecture, component library, and tooling we put in place. The 20k/year licensing cost is gone, replaced by a component library the team owns and extends as they need it. Every new project starts from a single CLI command instead of days of manual setup.

The strategy, the library, the templates, the processes: all still in use. All still growing. The team owns everything. That was always the point.