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

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.

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 client | Configuring one platform | |
|---|---|---|
| Speed for the next client | Fast at first | Fast once the platform is ready |
| Fixing a bug | Once per copy | Once |
| Adding a feature | Once per copy, or clients drift apart | Once, turned on where needed |
| Risk over time | Copies drift and break differently | One tested codebase |
We chose configuration. Here's what that took.

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.

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.

