Flow 01
Login and onboarding
Google OAuth opens a private family workspace where users create or join a household.
Backend resolves user identity, family membership, and active family scope.
Back to portfolio
Backend portfolio
Family Finance backend engineering case study
A production-minded family finance platform with a Go backend, cross-platform API boundaries, provider integrations, reviewable intake flows, and a documented scaling roadmap.
Role
API and platform ownership
3
client surfaces: web, mobile, integrations
14
web and mobile journeys documented for recruiters
0
private finance records exposed publicly
UI flow
A recruiter-readable product journey.
Screenshots explain what the product does. Each flow is paired with the backend decision it proves.
Flow 02
Dashboard overview
The dashboard summarizes income, expenses, budget health, goals, and household activity.
Aggregated read APIs provide family-scoped dashboard DTOs.
Flow 03
Transactions
Families can review, create, edit, and delete income or expense records.
Finance services validate categories and enforce tenant boundaries on ledger writes.
Flow 04
Budgets and categories
Category budgets show spend progress and help families see where money is going.
Budget and category services support reusable rules across web and mobile.
Flow 05
Family management
Invite codes, member lists, family switching, and ownership actions support multi-family use.
Backend-owned membership checks prevent clients from trusting caller-supplied family scope.
Flow 06
Intake review
Gmail, WhatsApp, AI, and receipt flows create reviewable drafts before ledger mutation.
Provider events become pending drafts, with duplicate checks and confirm/reject actions.
Flow 07
Settings and integrations
Users manage sessions, notifications, Gmail, Strava, Hevy, WhatsApp, and Google Sheets sync.
OAuth tokens and provider state stay server-side behind protected backend services.
Flow 08
Reports and export
Monthly reports, year-over-year comparisons, and CSV export make the data portable.
Report endpoints are the first candidates for read-model caching when traffic grows.
Mobile app journey
Native screens for repeat household finance moments.
The mobile app carries the same backend contracts into iOS and Android: fast glanceable summaries, secure mobile sessions, and family-scoped actions designed for repeated use.
Mobile API signal
Mobile bearer sessions and family-scoped DTOs
The journey is not a separate product story. It proves the backend supports web, native app, and provider integrations through shared domain boundaries.
Mobile 01
Mobile onboarding
iOS and Android entry screens introduce the household, authenticated account, and family context.
OAuth handoff ends in backend-issued mobile bearer sessions stored securely on device.
Mobile 02
Mobile dashboard
The mobile home view compresses net worth, savings, spending, goals, and recent activity into a touch-first surface.
Mobile dashboard APIs return family-scoped DTOs without exposing raw persistence models.
Mobile 03
Add transaction
A native transaction form supports amount, type, category, payer, account, date, notes, and split-with context.
Transaction writes are validated server-side against category, family, and member ownership.
Mobile 04
Budgets
Budget cards show remaining monthly allowance, category progress, and quick status signals.
Budget read models reuse the same backend ownership boundary as web, ready for cache-aside later.
Mobile 05
Goals
Savings goals and active challenges remain visible from the tab bar for repeated family check-ins.
Goal APIs protect family membership and keep progress calculations centralized in backend services.
Mobile 06
Family members
Member activity, invites, and household context translate the shared-finance model into mobile-native navigation.
Family switching and membership checks are backend-derived, not trusted from client-side route state.
Tech stack
Grouped by ownership boundary.
Web
- Next.js App Router
- React
- TypeScript
- next-intl
- NextAuth
Backend
- Go 1.26
- Gin
- GORM
- PostgreSQL
- domain services
- mobile and web API boundaries
Mobile
- Expo
- React Native
- SecureStore
- TanStack Query
- mobile bearer sessions
Integrations
- Google OAuth
- Gmail Pub/Sub
- WhatsApp webhooks
- Gemini
- DeepSeek
- Strava
- Hevy
Quality and deployment
- Vitest
- Go tests
- API contracts
- no web DB access checks
- Cloud Run planning
- Open Graph sharing
Backend maturity
Strong backend signal without infrastructure overclaiming.
Redis cache-aside
Redis is not currently implemented in family-finance-backend.
Add Redis later for dashboard and reporting read models, using family-scoped keys, short TTLs, and write invalidation.
Kafka assessment
Kafka is not currently implemented in family-finance-backend.
Use an outbox-first async model before Kafka; reserve Kafka for replayable multi-consumer event streams.
Durable jobs
The backend has Gmail Pub/Sub callbacks, worker-style backfill, goroutines, and an in-process monthly scheduler.
Move monthly summaries, push notifications, and provider retries to durable outbox-backed workers.
Observability
Request IDs, Cloud Armor planning, and tests exist, but metrics/tracing are not yet a full observability platform.
Add structured logs, metrics, traces, queue-depth alerts, provider latency tracking, and DB pool saturation alerts.
Backend proof points
What hiring managers should notice.
- Backend is the system of record for family-scoped finance data.
- Web and mobile clients consume stable backend DTOs instead of owning persistence.
- Mobile sessions are validated by backend middleware and stored as token hashes.
- Provider events are converted into reviewable drafts before ledger mutation.
- Redis and Kafka are documented as roadmap decisions, not inflated implementation claims.