Dealing with Legacy Core Systems as a PM
Feature Planning When Dependent on Banking Core APIs or Monoliths
Feature Planning When Dependent on Banking Core APIs or Monoliths
In the world of fintech development, few challenges are as persistent—and as underestimated—as dealing with legacy core systems. As product managers, we’ve learned that while innovation might be the end goal, much of our day-to-day execution is spent navigating the constraints of the past. If you’ve ever tried to launch a new payments feature or rewire a digital flow while tethered to a decades-old monolith, you know exactly what we mean.
This article explores practical strategies and hard-earned lessons for planning features when your velocity, reliability, and scope are all at the mercy of legacy core banking systems.
Legacy core systems weren’t built for agile. They’re often batch-based, API-thin, and rigidly structured. Whether you're dealing with COBOL-based mainframes or bloated core banking platforms with custom-built wrappers, the same problems surface:
Your beautiful product roadmap suddenly becomes a negotiation between what should be possible and what the core system will allow.
When core APIs become the bottleneck, your feature planning strategy must shift. Here’s how we typically approach it:
Forget documentation. Sit down with the tech leads or architects who’ve shipped features in that environment before. What seems like a supported capability (e.g., transaction categorization, real-time balance updates) may behave very differently in practice.
We often start new initiatives by asking:
How fresh is the data?
Can we get real-time calls, or only snapshots?
How often do downstream systems sync or batch?
If the backend won’t deliver in time, design your UI and flows to support phased rollouts. Use mock APIs or simulate flows where needed. This helps maintain delivery velocity and avoid blocking your teams while backend dependencies are resolved.
Example: Can’t offer instant transaction classification yet? Show placeholder categories and use async reconciliation to update later.
Modern middleware platforms or custom-built service layers can act as a decoupling zone. They’re perfect for hiding the ugliness of legacy APIs and exposing a modern RESTful or event-based interface to your feature teams. Middleware can also:
In our experience, putting this layer in place early is worth the time it saves down the road.
When you're working with constraints outside your control, expectation management becomes a critical PM skill. Here’s how to keep the project on track:
Communicate API limitations early to design, QA, and business teams
Document technical blockers as product risks in your roadmap
Negotiate scope—sometimes you need to remove functionality to hit a release window
Align timelines with core release schedules, especially if you need database schema changes or batch job modifications
Don’t be afraid to build around the core if necessary. Fintech history is full of clever solutions:
Shadow databases to store enriched data not supported by the core
Webhook-based callbacks to simulate async behavior
“Facades” for legacy services that allow frontends to work independently
Just ensure that every workaround has a sunset plan—or it becomes part of your next tech debt story.
Core banking teams often have different incentives and timelines. Your job is to bridge the gap, not bulldoze through it.
Bring them into discovery early. Don’t treat them as “the backend team you hand things off to.”
Work in sync sprints—even if loosely aligned—to avoid release bottlenecks.
Celebrate their wins too. A successful data migration or stable API release is just as important as your app launch.
Working with legacy core systems is part of building real, impactful fintech products. It teaches you how to make trade-offs, build incrementally, and move forward without having all the pieces perfect.
At OceanoBe, we build solutions that work with—and around—core banking challenges. We’ve shipped scalable architectures that talk fluently to monoliths, legacy APIs, and modern service layers alike. We know that success in fintech isn't just about writing clean code—it's about designing with constraints and executing with precision.
If you're struggling to modernize your stack or get features out the door faster, let's talk. Legacy shouldn’t hold you back—it should push you to build smarter.