FINTECH CASE STUDY
Piggy: A White-Label Financial Planning App, Built From the Ground Up
How WebSpero designed, architected, and shipped a full fintech platform (iOS, Android, and web in one codebase) with Finicity + Plaid bank connectivity, live advisor video & screen share, and a forward-projecting planning engine.

3
Platforms Shipped
iOS · Android · Web
1
Unified Codebase
React Native + RN Web
2
Aggregators
Finicity + Plaid
Live
Advisor Channel
Chat · Video · Screen Share
Project Context
Client
Piggy Fintech
Niche
Fintech Advisory SaaS
The Tech Stack
- React Native Web
- Node.js
- MongoDB
- Tailwind CSS
- AWS CDK
"The vision was for Piggy to feel
warm and intuitive, not like a cold,
spreadsheet-driven banking app."
Founder vision prioritized emotional security alongside technical robustness. We focused on expansive white space, soft lighting effects, and a refined color palette that prioritizes readability and cognitive ease.

Founder, Piggy
Strategic Vision Lead

THE APP
Piggy Fintech
Piggy is a white-label financial planning app. Each advisor runs their own branded practice on top of one shared engine, with a client app on iOS, Android, and web, and a matching admin app for the advisor.
For Clients
- Full financial life in one view: income, expenses, assets, and liabilities organised by folder (Me, Spouse, Car, Home, Pets)
- Bank and card accounts connected through Finicity or Plaid behind one simple “Find your bank” flow
- Transactions in a single searchable feed with categorised and uncategorised views
- Forward projection of cashflow, net worth, and federal + state taxes from the same data
- Messaging, 1:1 video, and screen share with their advisor, inside the app
- Available on iOS, Android, and desktop web
For Advisors
- White-label branding: each advisor runs the app as their own practice
- Client roster dashboard with unread message counts per client
- Split client view: conversation, profile, connected accounts, and plan on one screen
- Audited “Log in as Client” impersonation for troubleshooting and in-session review
- 1:1 video and screen share from the client detail screen
- Admin app on iOS, Android, and desktop web
HOW WE BUILT IT
A Structured, Founder-in-the-Loop Sprint Process
When Piggy’s founder first reached out, we didn’t start with a proposal template. We ran a structured intake, understood what a financial advisor needs from a tool they brand as their own, and designed the delivery plan around that. Below is the sequence we ran, from the first discovery call through the final build and handover.

DISCOVERY
A working session with the founder to capture the white-label vision, both user journeys, and the non-negotiables for the stack.

REQUIREMENT ANALYSIS
We broke the brief into epics: auth, onboarding, financial picture, plan, transactions, advisor channel,
admin dashboard, integrations, and mapped dependencies between them.

ARCHITECTURE & PLANNING
Picked React Native + RN Web with a shared component system, Node.js + MongoDB for the API, AWS CDK for
reproducible infra, and sequenced a phased delivery roadmap.

UI/UX DESIGN
High-fidelity Figma screens for every surface: custom emoji set for categories, a clean theme, and an icon language consistent across
mobile and desktop.

CORE BUILD
Auth, folder-based financial picture, income/expense/asset/liability entry, projection engine, cashflow + balance sheet +
tax views, all wired to the shared schema.

INTEGRATIONS
Finicity and Plaid normalised behind a single internal transaction model. Real-time messaging, video call, and screen share stitched
into both the client and admin apps.

QA & REGRESSION
Every release verified against expected financial outputs, run across iOS, Android, and desktop web, with a QA-founder-dev
triage loop on every sprint.

RELEASE BUILDS & HANDOVER
Release builds submitted to App Store and Play Store for client and admin apps, desktop web deployed to
production, and the source repo, AWS CDK infrastructure, and runbooks handed to the founder’s team.
WHAT WE BUILT
Four Connected Platforms Powered by a Single Projection Engine
Piggy ships as four connected experiences: client mobile, client web, advisor admin on mobile, and advisor admin on desktop. Below is the product, screen by screen, in the order a new user would meet it.
Authentication: Login, Create Account, and Error States
The entry point to every Piggy-branded practice. Login, account creation, and recovery were designed with empty, filled, and active states so advisors could white-label the flow without the UI breaking at any state.

Financial Picture: Folder-Based Organisation
The home screen of every client app: a folder per life area (Me, Spouse, Rent, Car, Pets, and so on), each showing its own cashflow, net worth, and delta. Adding a new folder is a single tap, and every folder is automatically tracked in the planning engine.

Income, Expense, Asset, and Liability Entry
A single structured form for every financial item: amount, frequency, cap, annual raise, and a bank-linked transaction search so real transactions feed straight into the projection. The same form powers income, expenses, assets, and liabilities: one data model, four use cases.

Bank Connection: Finicity + Plaid Behind One Flow
Users see a single “Find your bank” screen with a clean bank grid. Under the hood, each bank is routed to either Finicity or Plaid depending on reliability and coverage, and the transactions land in Piggy’s unified transaction model regardless of which aggregator handled the link.

Transactions: Categorised, Uncategorised, and Full Feed
Once accounts are linked, transactions flow into a single searchable feed with three filtered views. Clients can categorise quickly; advisors can see the uncategorised pile at a glance and help close it out.

Plan: Forward Projection of Every Asset and Liability
Each asset (home, car, investment) or liability (loan, credit line) gets its own timeline: purchase date, sale date, appreciation, market-crash scenario. The planner rolls each item forward individually and rolls them up into the aggregate view.

Cashflow, Worth & Taxes: Three Tabs, One Projection
The summary view every client and advisor lives in. Cashflow and net worth are each computed from the same folder structure, and the tax tab pulls federal and state estimates from the underlying income and deduction model. All three tabs stay in sync because they share one data source.

Profile, Connected Accounts, Knowledge Base, and Account Deletion
The profile section is where every trust-sensitive action lives: managing connected bank accounts, browsing the knowledge base tour, notification preferences, and a deliberately friction-heavy account deletion flow that routes the user through their advisor rather than deleting silently.

The Planner: Desktop Web Workspace
The same React Native codebase renders a multi-panel desktop planner: the Financial Picture column on the left, a visual timeline across the middle, a detail view for the selected item, and a full cashflow/worth/tax read-out on the right, all interactive and in sync.

Advisor Admin Dashboard
Advisors see their entire client list on one screen, with unread message counts per client. Tapping a client opens a split view: the full conversation on the left, the client’s profile and notes in the middle, and all their connected accounts and balances on the right. A “Log in as Client” button sits alongside, so the advisor can walk into the exact view their client is seeing.

Live Video Call + Screen Share
Advisor and client can jump into a 1:1 video call straight from the conversation, and either side can share their screen to walk through the numbers in real time. The screen below is an advisor reviewing a client’s federal + California tax estimate during a call; no Zoom, no external tools, no context switch.

THE CHALLENGES WE SOLVED
Engineering Mathematically Flawless Projections and Secure Real-Time Channels
Piggy is an advice tool, so the numbers have to be right on every platform. Six engineering problems shaped the build:
One Codebase, Three Render Targets
One React Native + RN Web codebase; every screen behaves on iOS gestures, Android keyboards, and desktop mouse input, from one source.
Two Bank Aggregators, One Transaction Model
Finicity and Plaid return different shapes for the same account. We normalised both behind one internal schema, with deduplication and webhook retries.
Real-Time Advisor ↔ Client Channel
Native chat, 1:1 video, and screen share on every platform, with low-latency signalling, resilient reconnect, and correct permission handling across iOS, Android, and the browser.
A Projection Engine With Numbers That Don't Drift
We wrote the cashflow, net worth, and tax math once, locked it behind regression assertions with $0.01 tolerance, and ran the full suite on every release.
Icon Set Mapped To Financial Categories
A custom emoji set mapped to financial categories (home, car, pets, utilities, dentist, diapers) so a long folder list is scannable at a glance.
Security Posture For Bank And Tax Data
Aggregator tokens server-side only, audited “Log in as Client” impersonation, per-environment secrets, and a documented breach-response path, in place before beta.
WHAT WAS DELIVERED
A Production-Ready, White-Label Financial Ecosystem
Piggy was delivered as a full platform: client apps on iOS and Android, an admin app for advisors on iOS and Android, and matching desktop web experiences for both. Every surface ships from the same React Native Web codebase, talks to the same Node.js and MongoDB backend, and deploys through AWS CDK.
| VISION | DELIVERED | |
| Platform Reach | Idea of one app on all surfaces | Client and advisor apps on iOS, Android, and desktop web from one shared build |
| Bank Data | Connect to “all” US banks | Finicity + Plaid behind one unified transaction model |
| Advice Delivery | Chat + call + screen share with clients | Native messaging, 1:1 video, and screen share inside Piggy |
| Projection Engine | “Project finances into the future” | Cashflow, net worth, and federal + state taxes on one data source |
| Brand Feel | Modern, approachable, trustworthy | Custom icon + emoji system, clean theme, white-label ready |
WHAT TO EXPECT FROM US
Transparent Engineering and Predictable Delivery for Regulated Products
If you are building a fintech product and you are weighing agencies, here is what working with our team actually looks like, in plain language.

A plan before a proposal.
We start with a working session to understand what your product needs to do, who it serves, and where the hard parts are. You leave with a delivery plan, not a sales pitch.

A live demo every two weeks.
At the end of every sprint, you see the actual product: what’s built, what’s working, and what we’re still figuring out. You always know where your product stands. No month-long silences followed by a surprise reveal.

One team, all your platforms.
You get a single team handling iOS, Android, and web together. You don’t pay for three separate teams that don’t talk to each other, and you don’t end up with three slightly different apps that feel like different products.

Experience with the hard parts.
Bank connections, payments, secure logins, financial calculations; we have shipped these into production for real customers. They are not research projects for us, which means you skip a year of trial and error.

Quality that does not depend on one person.
Every change is tested automatically before it reaches you. Every release is reviewed by QA, by your team, and by us together. Nothing ships because one engineer said it was fine.

Security built in from day one.
Your users’ financial data is handled the way a bank would handle it, encrypted, access-controlled, and audited. Protection from day one, not a checklist at the end.

You own what we build.
At handover, you get the full product: the code, the documentation, the access keys, the operational guides. Your team can take it forward on their own, or keep us on, your choice, not a lock-in.

A founder-friendly working rhythm.
You are in every demo, every trade-off conversation, every milestone. You are not a ticket number to us; you are the product’s first and most important user.
TECHNICAL NOTES
The Architecture, Infrastructure, and Tooling Powering Piggy
Monorepo & Build
One React Native + React Native Web project, shared components, platform-specific entry points for client iOS, client Android, client web, admin iOS, admin Android, admin web. [INSERT: Metro config, Nx/Turborepo, Expo vs bare.
Accessibility & Localisation
Shared components meet [INSERT: WCAG 2.1 AA] for contrast and touch targets. Current release scope is US-only with federal + state tax; structure is in place to expand currencies and tax regimes.
Authentication & Impersonation
Advisor-side “Log in as Client” runs through an audited impersonation flow, not a session handover. [INSERT: Auth provider: Cognito / Auth0 / Clerk / custom JWT, and audit-log destination.
Video, Messaging & Screen Share
Real-time advisor ↔ client channel built on [INSERT: Twilio Video / Agora / Daily / LiveKit / raw WebRTC], with resilient reconnect and platform-native screen-capture permissions.
Bank Aggregation
Finicity + Plaid normalised behind one internal schema with webhook retries, duplicate detection across aggregators, OAuth-token refresh, and a re-auth UX when tokens expire.
Infrastructure
AWS CDK provisions [INSERT: ECS Fargate / Lambda + API Gateway], [INSERT: MongoDB Atlas / DocumentDB], S3 + CloudFront for the web build, and environment-per-branch deployments.
Observability
[INSERT: Sentry / Datadog / OpenTelemetry] for errors and traces; structured logs on every projection recompute so silent numerical drift is catchable in production.
QA & CI/CD
[INSERT: Jest + Detox / Maestro / Playwright] on every PR; visual-regression on the shared component library; release automation through [INSERT: EAS Build / Fastlane / Bitrise] with CodePush for OTA updates where allowed.
