You are Lisa. You work at Megabank. Your team builds the account management part of the website-transaction lists with filters and queries, charts for account levels, and statement exports in .csv and .pdf. You’ve built a sleek backend in Go and a frontend in Svelte, all running on a Kubernetes cluster that you manage.
Your buddy Steve, two floors up, builds the investment banking part of the customer portal. Portfolio lists with filters and queries, charts for market prices, and order exports in CSV and PDF. They used Node for WebSocket connections, Erlang for the processing side, and React for a smoother frontend experience.
Hanna, on floor five, handles credit cards. Her team has developed a nice customer portal featuring a list of credit card charges that can be filtered and queried. Pretty charts allow you to track debt levels over time. And, for extra convenience, you can export your charges in CSV and PDF. Hanna’s team implemented all this in PHP running on Apache servers, with a frontend in Angular.
All three teams adhered to the corporate branding guidelines, so their products look and feel reasonably similar. They also work fairly well and were shipped on time.
But-great news! Megabank has hired some new top talent. Mike comes from the mythical lands of tech and management consultancy. He’ll be the super senior VP of platform at Megabank.
Good Inefficiencies
It takes Mike just two days to realise that work at Megabank is highly inefficient. Each team has reimplemented the same functionality over and over again. They are also relying on their own stacks, so transferring people between teams is much harder. Sure, they shipped quality products on time-but with Mike’s process improvement expertise, imagine how much more they could be doing…
Mike creates a fourth team-the platform team. That team has two tasks:
- Set standards that every other team has to adhere to. The platform team will conduct careful research and then decide on one stack that all other teams have to use and one standard they have to follow. This will allow for knowledge sharing and inter-team transfers.
- Create a shared component library for other teams to use. This will include a generic list with filters and queries, a time-series data model with an abstract chart library, and universal export to CSV and PDF.
Soon, the platform team goes to work. They decide that backend functionality will be implemented in Go from here on, frontends in React, and everything will be hosted on Kubernetes. As far as platform teams go, this is a very modern and common-sense decision.
The other teams start learning these technologies. Some already have some experience; others have to learn from scratch-but those are just temporary teething pains. Soon, everyone will have adjusted to the new reality and efficiency will skyrocket.
Except maybe for the investment banking team. They really need their Erlang architecture for decentralized networking-after all, they process fast-moving market data, order execution, and the like.
It also turns out that Go is overkill for the credit card guys. They just need a simple model-view-controller architecture like PHP provides. Having pointers to memory addresses and managing concurrency via goroutines rather than just writing linear PHP that Apache runs in parallel is really much more than they bargained for.
But at least on the frontend side, a lot of time will be saved. The new list components and charts are well designed and can just be dropped into a customer portal, saving lots of development time. Except for the investment banking team-they need candlestick charts that were supported by their chart library but haven’t made it into the generic charting component yet. They raise a ticket with the platform team, but it gets deprioritised since the CSV and PDF exports have to be implemented first.
The credit card team is also really struggling with porting their backend to Go. They ask if they could use the transaction list from the platform team but send the same data format from their existing PHP implementation. The platform team doesn’t want to be seen as the obstacle, so they agree. But writing documentation for the internal data structure of the transaction list component hasn’t been planned for-after all, it was never meant to be available externally. And really, the focus right now is on building the PDF and CSV exports.
Unfortunately, this year, none of the teams will be shipping much. But Mike made an amazing presentation called “Megabank platform vision 2028 – a road to global efficiency”. So his bonus will be fine.
This story has played out too many times. You were probably part of it at some point. And it makes sense on its face. The inefficiencies are real. But-they are necessary. Different requirements need different solutions. Different people know different things. Standardisation and abstraction seem like good solutions on their face but are hard to implement in practice. Minor differences multiply into large, unwieldy problems.
Service-Oriented Architecture
The solution is often the opposite of what good software design teaches. Do Repeat Yourself. At least, allow for some level of repetition. But more importantly, create clear boundaries within which teams can be flexible, and clear interfaces and protocols to interact and combine their services.
This idea is as old as the internet-and is often called Service-Oriented Architecture, or SOA for short.
Think of service-oriented architecture like going to a street food market. Each vendor has a little booth with a menu of available options. If you want to order something, you know you need to talk to the vendor, request your option, and pay using a shared currency or card. That’s the common interface. How the vendor prepares the food, where they source their ingredients from, which kitchen appliances they use-all of that is not your concern. You interact with the common interface.
For our three teams, that means that each can continue using their stack and approach and ship at their own cadence. But Mike also had a point with his platform team. There are things that are necessary for a user experience to not feel disjointed. And there are capabilities, such as DevOps, that are best handled centrally. So, rather than prescribing an exact technology stack and building shared components, Mike shifts the platform team’s responsibility. It now:
- Standardizes that all backend functionality has to be shipped as Docker Containers and all frontend functionality has to be compiled into static files that can be loaded via CDN.
- Prescribes standards for API design and structure. All teams have to offer their services through a clear RESTful HTTP API, documented with Swagger and following common conventions. How that API is implemented is each team’s decision.
- Provides a shared CSS framework for UI elements. This can be applied to HTML created by any framework and creates a common look and feel.
- Provides the outer framework for the user portal: navigation, asset loading, and module bundling. This accepts some pretty major inefficiencies-whenever the user switches from the account view to the investing tab, a whole new JS framework is loaded. But, given all other factors, this is an acceptable trade-off.
- Creates a universal documentation base that all other teams contribute to. This provides transparency and knowledge sharing and helps to keep teams from becoming siloed.
With these changes, efficiency rises back up. Not because the teams stopped rebuilding the same thing, but because they’ve stopped getting in each other’s way. Some code is duplicated. Some problems are solved three different ways. And that’s fine. Minimizing the amount of code written or the number of technologies used isn’t a goal in itself - but building good products, shipping them on time, and allowing teams to work effectively together is. Sometimes, the most efficient thing you can do is to let people repeat themselves.