Client assignment

When regulations, business logic and user experience needed to work together

How we built a configuration-driven platform for occupational pension

A large company in the financial sector faced a growing problem. Each customer solution was, in practice, run as its own application, with separate codebases, server environments and release processes.

This resulted in high costs, a low rate of change and increasing technical debt. Every change had to be implemented and tested multiple times, with a risk of inconsistency and errors.

The challenge was not to develop more functionality – but to create a structure that made it possible to manage complexity in a controlled way.

3+ years

Stable operation without incidents
100%

Stability in production over time

Background – a shared product with different terms

Our client operates digital services in the occupational pensions sector, where multiple customer groups and agreements need to be supported within the same operations.

Although the services are similar, business rules, legal terms and user flows differ between different portfolios and agreements.

Previously this was solved by separate applications for each customer variant. That provided short-term flexibility but created major problems over time:

several codebases to maintain
duplicated functionality
complex release management
increased operating costs
higher risk when making changes
difficulties introducing new features consistently

Strategic direction

Instead of continuing to build separate solutions, we chose a different path together with the client. The goal was to create a common platform where variation between customers, agreements and user groups is handled via configuration rather than customer-specific code.

This implied three central principles:

One platform – one codebase

Functionality was gathered in common applications instead of separate implementations per customer or portfolio. This created better control over development, quality assurance and maintenance.

Configuration instead of hardcoding

Texts, rules, interfaces and functionality that vary between different customer solutions are handled via configuration. This makes it possible to introduce new variants without creating new codebases.

Real-time dynamics

The platform adapts dynamically depending on users, business data, permissions and regulations. The same solution can thus support several complex scenarios within the same architecture.

Technology and architecture

The solution is built on a modern, modular architecture where the frontend, integration layer and business systems are clearly separated. This creates better conditions for scalability, further development and long-term maintenance.

The frontend was developed in React and TypeScript to enable a responsive, dynamic interface, while the API and integration layers in .NET handle communication, business logic and integrations with backend systems.

A headless CMS is used for content and communication, enabling dynamic management of content and variations without affecting the application's codebase.

The architecture is complemented by a configuration layer that controls functionality, rules and the user experience depending on customer, user role and business data.

Configuration management as an architectural principle

At the core of the solution is a configuration layer that controls how the application behaves depending on customer, user role, portfolio and business rules.

The configurable content includes, among other things:

Content and communication

Texts, labels, help messages and language are handled dynamically via the CMS and can be customized per customer or user type without code changes.

Design and interface

The solution is based on a component-based design system with support for multiple graphical themes and dynamic interfaces.

Functionality and business rules

Business logic and user flows are governed via configuration and rule engines rather than hard-coded implementations. This makes it possible to handle large variations without technically fragmenting the solution.
To support complex rule sets, a rule engine was also developed that can interpret and evaluate rules in real time based on data from multiple sources.

This enables, among other things:

dynamic validation
conditional flows
role-based functionality
dynamic display and control of data
real-time adaptation of the user experience

Results and impact

The result is a fast, responsive application that can handle high complexity without being perceived as complex by the user. Since deployment the solution has been running stably without incidents.

The project also created better conditions for the business to develop new services and implement changes without every initiative becoming an extensive technical project.

Benefits for our client:

lower maintenance and operating costs
faster onboarding of new customer variants
better control over release management and quality
reduced technical debt
increased flexibility for further development
higher stability and delivery reliability

Our role in the project

We worked closely with the client's internal team and acted as both a technical partner and an implementation partner throughout the project.

Together with the client we worked on:

vision and technical strategy
architecture and integration principles
structure for configuration management
UX and user flows
analysis of business processes and regulations
design system and frontend architecture
long-term maintenance and further development

Building for change

This project is an example of how to create control in complex digital environments where technology, business rules and user experience need to work together.

For us, modern system development is not just about delivering functionality. It's about building platforms that make businesses faster, more flexible and better equipped for change over time.

Do you have similar challenges? Feel free to get in touch and we'll tell you more.