BillGo · Software Engineer II → III
Fintech SDK Platform
Jul 2021 to Mar 2024
Architected a cross-platform fintech SDK. A headless + UI library system that collapsed third-party integration timelines from months to days and cut downstream development effort by 90%.
90%
Integration overhead cut
Reduction in downstream development effort per client integration, going from multi-month bespoke builds to a configuration-driven onboarding path
50%
Faster test cycles
End-to-end testing time cut in half through Detox automation, freeing engineers from manual regression testing on every release
Days
Time to integrate
New client integrations that previously took months could be completed in days with the SDK's reference apps and configuration-driven setup
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.
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.
Headless + UI library split
The core SDK was built as a headless library. Pure logic, state management, and API contracts with no UI opinions. A separate UI library shipped pre-built React Native components on top of it. This gave clients maximum flexibility: adopt the UI components out of the box, or use only the headless layer and build their own interface.
Native iOS and Android reference apps
Rather than shipping the SDK untested, built complete native iOS and Android apps using it. They served as both validation of the architecture and as reference implementations clients could learn from. This caught integration edge cases before they became client problems.
CSS variable-based theming system
Designed a modular theming architecture using CSS custom properties and design primitives. Clients could white-label the UI with their brand colors, typography, and spacing through a single configuration object. No custom builds required.
Detox + GitHub Actions automation
Implemented Detox end-to-end testing for the React Native SDK and wired it into GitHub Actions pipelines. Automated tests ran against real device simulators on every PR, catching regressions before they reached client environments.
Offline-first data synchronization
Built scalable data synchronization and caching within the UI SDK, enabling real-time and offline product use cases. Clients whose users operated in low-connectivity environments got reliable behavior without building their own sync layer.
What shipped
- ✓Cross-platform SDK with headless and UI library layers, supporting React Native, iOS (Swift), and Android (Kotlin) integration paths
- ✓Native iOS and Android reference applications fully built on the SDK for validation and client onboarding
- ✓Modular theming system using CSS variables enabling white-label branding from a single configuration
- ✓Detox-based end-to-end test suite with GitHub Actions CI/CD pipeline for automated regression coverage
- ✓Offline-capable data synchronization layer with real-time update support
- ✓Internal React Native tooling apps for backend API simulation and developer validation workflows
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.
Hiring for work like this?
Share this case study with your team, or get in touch directly.