Fintech SDK Platform

BillGo built bill payment infrastructure for financial institutions and fintech companies. Every new client partnership required a custom frontend integration. A bespoke build that duplicated effort, introduced inconsistency, and created a bottleneck on the commercial side. The company needed a way to scale its client ecosystem without scaling its engineering headcount linearly.

I led the SDK architecture end to end, from the headless/UI library split through the theming system and Detox-based test automation. The native iOS and Android reference apps were built as part of that same effort to validate the architecture before client rollout.

Every integration was starting from zero

Without a shared SDK, each new client integration was a greenfield frontend project. Engineers were rebuilding the same payment UI patterns, authentication flows, and data synchronization logic from scratch, accumulating technical debt and slowing down deals that depended on fast time-to-integration.

• No shared component layer. Each client integration duplicated the same UI patterns, payment flows, and state management
• No cross-platform strategy. Mobile integrations required separate bespoke implementations for iOS and Android
• Integration timelines stretched into months, directly impacting commercial velocity and client satisfaction
• No automated test infrastructure for integration scenarios, making regressions hard to catch before they reached clients
• Branding and theming were hardcoded per client. Any white-labeling request required a custom build

Build the platform once, integrate it everywhere

The solution was a two-layer SDK architecture: a headless library that handled all business logic, state, and API integration, plus a UI layer with pre-built, themeable components built on top of it. Clients could use the full stack or bring their own UI. Either path was supported without duplication.

What shipped

• ✓Gave every client a flexible integration path with a cross-platform SDK spanning headless and UI library layers, across React Native, iOS (Swift), and Android (Kotlin)
• ✓Validated the architecture and gave new clients a working reference with native iOS and Android reference applications built fully on the SDK
• ✓Turned white-label branding into a single configuration change with a modular theming system built on CSS variables
• ✓Caught regressions before they reached clients with a Detox-based end-to-end test suite wired into a GitHub Actions CI/CD pipeline
• ✓Kept the product usable in low-connectivity environments with an offline-capable data synchronization layer supporting real-time updates
• ✓Sped up backend API simulation and developer validation with internal React Native tooling apps

A platform that scaled client growth without scaling headcount

The SDK transformed the integration story at BillGo. New clients went from multi-month custom builds to days-to-integrate. The headless/UI split meant the SDK worked across every client's technical constraints. And the automated test infrastructure meant regressions surfaced in CI rather than in production.

The headless/UI split was the highest-leverage architectural decision. It looked like more work upfront (two libraries instead of one), but it made the SDK genuinely useful across a wider range of clients. The clients with strong design teams used only the headless layer. The clients moving fast used the UI components. One codebase served both, and neither felt like they were compromising.