Skip to content
All case studies
Enterprise analytics team at a Fortune 500 technology company · Enterprise Analytics

From One-Off Build to Multi-Client Platform: Generalizing an Enterprise Analytics App

An enterprise expense analytics app was built for one client, and more wanted it. Across two phases, I helped turn it into one white-label platform where client differences live in configuration, not copies of the code.

Client
Enterprise analytics team at a Fortune 500 technology company
Industry
Enterprise Analytics
My role
Data Engineer, then Senior Software Engineer
Duration
Two phases, about 19 months
Built to serve multiple clients instead of one copy each
1 codebase
Client-specific behaviour switched on in config
Flags, not forks
Migrated off WebSphere to a lighter, container-friendly runtime
Open Liberty
One central glowing block branching into several identical dashboards, each in a different accent colour

Here's a pattern I've seen more than once: a company builds an application for one client, it works well, and a second client wants the same thing. The fastest move is to copy the code and change what's different. Then a third client arrives. Then a fourth.

A year later, there are four versions of the same product, each slightly different, and every bug fix has to be made four times.

This project was about avoiding that. The application was an expense analytics platform (Expense Insight), built by a Fortune 500 company's analytics team for an enterprise client. The goal was to turn it from a one-off build into a single platform that could be white-labeled for multiple clients.

I worked on it across two phases.

A single sturdy tree trunk branching into several healthy limbs, each with slightly different colored leaves

Phase 1: From prototype to MVP

The first phase converted the application into a working MVP for its first client. My focus was the data side:

  • Python scripts for data ingestion and automation
  • Docker containers for the machine learning modules, so they ran the same way on every environment
  • Apache Airflow jobs to orchestrate the data pipelines running inside those containers
  • Support and maintenance of the existing Angular, Java EE and DB2 stack and its CI/CD pipeline

This phase delivered a working product. It also showed us exactly which parts were tied to one client, which became the map for phase two.

Phase 2: One codebase, many clients

In the second phase, the client wanted the platform generalized so it could support multiple clients instead of being rebuilt each time.

The central question was simple: when two clients need different behavior, do you fork the code or configure it?

Forking per clientConfiguring one platform
Speed for the next clientFast at firstFast once the platform is ready
Fixing a bugOnce per copyOnce
Adding a featureOnce per copy, or clients drift apartOnce, turned on where needed
Risk over timeCopies drift and break differentlyOne tested codebase

We chose configuration. Here's what that took.

A control panel with a neat row of physical toggle switches, some flipped on with soft teal indicator lights

Settings moved out of the code

The API had client-specific values like URLs and version numbers written directly into the code. I moved them into configuration files, so a new client meant a new config, not a code change.

Feature flags instead of forks

Where clients genuinely needed different behavior, I added feature flags: simple on/off switches in configuration. Client-specific behavior became something you toggle, not something you copy.

Build scripts that work for any client

The Docker build scripts had been hardcoded to one repository and one client. I made them repository-agnostic, and wrote shell scripts to build and push containers to each client's registry, so the same pipeline worked for every client build.

Reuse, not reinvention

For the data pipelines, I reused the existing Airflow workflow patterns rather than writing new ones. Consistent pipelines are easier to support, and support was going to multiply with every new client.

Off WebSphere, onto Open Liberty

I also led the migration from IBM WebSphere to Open Liberty, a lighter, more modern Java runtime that is better suited to containers, and handled the client-specific single sign-on integration that came with it.

The result

The platform went from a one-client build to a single codebase designed to serve multiple clients. Client differences live in configuration and feature flags instead of separate copies of the code, and the same build pipeline works for every client.

That's the difference between a product that gets harder to maintain with every sale and one that gets more valuable.

An engineer's monitor showing several identical dashboard layouts side by side, each in a different accent color

When should you make this move?

You don't need a multi-tenant, white-label platform for your first client. That would be over-engineering. But watch for these signs:

  • You're about to copy the codebase for a second or third client
  • Bug fixes have to be applied in more than one place
  • "Small" client-specific changes are scattered through the code
  • New client setups need a developer instead of a configuration change

When those show up, that's the time to invest in generalizing, before the copies drift too far apart to bring back together.

If you're selling the same software to more and more clients and maintenance is getting heavier with each one, let's talk about what it would take to turn it into one platform.

Tech stack

  • Python
  • Apache Airflow
  • Docker
  • Kubernetes
  • Java EE
  • Open Liberty
  • Angular
  • DB2

Client details are shared with permission or anonymised, and some specifics are changed to protect confidential information. Results are from this project and aren't a guarantee for others. Views are my own. Full disclaimer

Have a similar challenge?

Tell me about your project and I'll come back with how I'd approach it.

More case studies