Engineering

How I build.

I started in engineering, moved into product, and now lead both. The mobile apps I’m responsible for move real money, so I care as much about how they’re built and shipped as about what they do.

How hands-on I am today: actively involved in the details, without losing sight of the bigger picture.

Mobile architecture

Feature modules with one source of truth.

Each feature (transfers, sub-accounts and approvals, the partner plug-in) is a self-contained module with its own state machine, so a screen can only show a state the money is actually in. Permissions are loaded on the device for display, but every money-moving request is re-checked by the server.

Reliability lives in the networking layer: idempotency keys on every send, retry with back-off, and safe resumption when the app closes mid-transfer.

Presentation

Flutter UI. Screens render from the user’s role and the feature’s current state; nothing is shown that the user can’t do.

Feature modules

  • Transfers
  • Sub-accounts and approvals
  • Bills
  • Cards
  • QR Pay
  • Partner plug-in

Self-contained, each with its own state machine and tests.

State and domain

Explicit states (draft → confirmed → processing → successful, failed, reversed). State management: Riverpod, BLoC / Cubit, Provider, GetX.

Networking

Idempotency keys on every money request, retry with back-off, certificate pinning.

Offline

Safe resumption if the app closes mid-transfer; cached reads.

Secure storage

Tokens and credentials in the platform keystore; PIN or biometric to confirm.

Server re-checks role, account and limit on every money-moving request. The client is never trusted.

Reference architecture for the Raven mobile apps, as described across the case studies.

Stack

  • Flutter
  • Kotlin/Swift
  • React Native

QA automation

Quality built in, not checked at the end.

Before, each release took 3 days of manual regression. Now most coverage runs on every pull request, and the slow end-to-end suite guards the journeys where money moves: login, send, receive, bills and cards. Each product’s engineers own their tests; there is no separate QA handoff.

Production defects per release, indexed

Six months before is set to 100; absolute defect counts are withheld for confidentiality. Attribution: my team’s work.

Delivery automation

From commit to store, with gates that stop themselves.

  1. Pull request

    Under 20 min

    Lint, type checks, unit tests, smoke end-to-end suite.

    All green to merge

  2. Merge and build

    Every merge

    Built for staging or development and shipped internally for testing.

    Internal build passes

  3. Release candidate

    Weekly

    Automated store builds, release notes, release checklist.

    Critical-path tests pass

  4. Staged rollout

    About 5 days

    1% → 10% → 50% → 100%, monitored in Crashlytics and Sentry.

    Crash-free ≥ 99.5%

Commit to store in four gated stages, on GitHub Actions and Codemagic. Nightly, the full end-to-end suite runs on real devices.
  1. 1%
  2. 10%
  3. 50%
  4. 100%

Gate between every step: crash-free sessions ≥ 99.5% in Crashlytics and Sentry, or automatic halt.

Staged rollout. Each step holds until crash-free sessions stay at or above 99.5%; a crash or error spike halts it automatically.
Release cadence
Bi-weekly → weekly, by month 3. My team’s work.
Rollback
A crash or error spike during the staged rollout halts it automatically, before most users see the release. The POS terminal app rolls out by partner cohort with automatic rollback.
Feature flags
Unfinished work ships behind flags, so we release weekly regardless of feature size. The cost: flag clean-up is ongoing work.

Tools

  • GitHub Actions
  • Codemagic
  • Crashlytics
  • Sentry
  • Bitrise

Engineering practices

The habits that keep it working.

  • Definition of done

    Tests are part of done. A feature isn’t finished until its money paths are covered.

  • Observability

    Crash-free sessions are tracked in Crashlytics and Sentry; they rose from 98.7% to 99.7% over 6 months, and they gate every rollout at 99.5%.

  • Code review

    Improves code quality and consistency while fostering knowledge sharing and collective ownership. Creates opportunities for engineers to learn from one another, catch defects earlier, and reduce avoidable rework.

  • Incident handling

    Strengthened the team’s ability to respond to and recover from production issues. Established clearer ownership, encouraged root-cause analysis, and shifted the culture from simply fixing bugs to preventing recurring incidents and improving system reliability.

The full story

Read the QA and delivery case study

Contact

Have a product that needs to ship well?

I’m open to global roles leading product, mobile engineering, or both. Email is the fastest way to reach me.