Showcase concept Studio showcase — a concept build demonstrating our approach.

Pulse

Mobile banking that feels instant — and is provably correct.

Discipline
App · iOS + Android · Fintech
Stack
SwiftUI, Jetpack Compose, shared Rust core, Postgres
Timeline
20 weeks (concept plan)
Role
Product engineering, native build, security review
01 — The brief

Money moves at the speed of thought.

Pulse is a fictional neobank for people who check their balance twelve times a day. The concept brief: unlock to balance faster than you can blink, send money with one thumb, and never — ever — show a wrong number.

Two native apps, one source of truth. The interaction model is built around biometric trust: Face ID or fingerprint gates every sensitive action without adding a single extra screen.

Audience
18–40, mobile-only banking
Platforms
iOS 17+ · Android 10+ · watchOS glance
Must-haves
Biometric auth, real-time ledger, instant P2P
Compliance
Designed for CDR & PCI-DSS scope reduction
02 — The challenge

Fast and safe. Usually you pick one.

Security adds friction; speed invites shortcuts. Most banking apps land somewhere grey — spinners on every tap, balances that lag the truth. Pulse needed optimistic UI on top of a ledger that can't lie.

  1. C/01

    Biometrics without friction

    Keys live in the Secure Enclave / StrongBox. Authentication unlocks a signing key — never a stored password.

  2. C/02

    Optimistic, but honest

    Transfers show instantly, then reconcile against a double-entry ledger. A rollback must animate, not jump.

  3. C/03

    Two platforms, no compromise

    Native SwiftUI and Compose for feel; shared Rust for the logic that must behave identically.

03 — Approach

Threat model first.

We design the attack surface before the UI, then make security invisible to the person holding the phone.

  1. 01
    wk 1–3

    Threat model & flows

    STRIDE across every money-moving flow. Each sensitive action gets a trust level, a biometric policy and an audit event.

  2. 02
    wk 3–8

    Shared Rust core

    Ledger maths, request signing and offline queueing in Rust, exposed to Swift and Kotlin through UniFFI — tested once, shipped twice.

  3. 03
    wk 6–16

    Native UI, twice

    SwiftUI and Jetpack Compose, each idiomatic. Spring physics tuned per platform; 120Hz on ProMotion devices.

  4. 04
    wk 16–20

    Hardening

    Certificate pinning, device-integrity attestation, an external pen-test and a staged rollout behind feature flags.

04 — Interactive

Unlock. Check. Send.

A working mini-flow in a CSS-built phone. Tap Face ID, then send money — the confirmation runs on a real spring simulation.

  1. 01Unlock
  2. 02Balance
  3. 03Send
  4. 04Confirmed
Tap to unlock with Face ID
under the hood

Face ID evaluates locally in the Secure Enclave. Success unlocks a device-bound signing key — no password ever leaves the phone.

LAContext.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics)
05 — Engineering highlights

Where the craft lives.

E/01

Biometrics unlock keys, not screens

The private key never leaves the Secure Enclave. A successful Face ID evaluation lets us sign the transfer payload — the server verifies the signature, not a session cookie.

Pulse/Auth/TransferSigner.swift
actor TransferSigner {
    private let key: SecureEnclave.P256.Signing.PrivateKey

    func sign(_ transfer: Transfer) async throws -> SignedTransfer {
        let context = LAContext()
        context.localizedReason = "Confirm \(transfer.amount.formatted())"
        context.touchIDAuthenticationAllowableReuseDuration = 0

        try await context.evaluatePolicy(
            .deviceOwnerAuthenticationWithBiometrics,
            localizedReason: context.localizedReason)

        let payload = try JSONEncoder.canonical.encode(transfer)
        let signature = try key.signature(for: payload)
        return SignedTransfer(payload: payload, signature: signature.derRepresentation)
    }
}
E/02

A ledger that can't lie

Shared Rust core: every movement is a balanced pair of entries. Optimistic UI applies a pending posting; reconciliation either confirms it or animates it away.

core/src/ledger.rs
#[derive(Debug, Clone)]
pub struct Posting { pub account: AccountId, pub amount: Cents, pub state: State }

impl Ledger {
    /// Apply a transfer as two postings that must always sum to zero.
    pub fn transfer(&mut self, from: AccountId, to: AccountId, amt: Cents) -> Result<TxId, LedgerError> {
        let available = self.available(from);
        if available < amt {
            return Err(LedgerError::Insufficient { available, requested: amt });
        }
        let tx = TxId::new();
        self.pending.insert(tx, [
            Posting { account: from, amount: -amt, state: State::Pending },
            Posting { account: to,   amount:  amt, state: State::Pending },
        ]);
        debug_assert_eq!(self.pending[&tx].iter().map(|p| p.amount).sum::<Cents>(), 0);
        Ok(tx)
    }
}
E/03

Springs, tuned per platform

Compose and SwiftUI each get their own spring constants — Android feels Android, iOS feels iOS — but share the same state machine from Rust.

android/ui/SentConfirmation.kt
@Composable
fun SentConfirmation(state: TransferState, onDone: () -> Unit) {
    val scale by animateFloatAsState(
        targetValue = if (state is TransferState.Settled) 1f else 0f,
        animationSpec = spring(dampingRatio = 0.52f, stiffness = Spring.StiffnessMediumLow),
        label = "check-scale",
    )
    val haptics = LocalHapticFeedback.current
    LaunchedEffect(state) {
        if (state is TransferState.Settled) haptics.performHapticFeedback(HapticFeedbackType.LongPress)
    }
    CheckBadge(Modifier.graphicsLayer { scaleX = scale; scaleY = scale })
}
06 — Targets & results

Numbers we build to.

Build targets and simulation benchmarks for this concept — the budgets we'd contract on a real engagement.

  • Target · iPhone 13380msFace ID to visible balance
  • Benchmark · simulated10MTransfers, zero ledger imbalances
  • Target120HzAnimations on ProMotion
  • Target99.9%Crash-free sessions
07 — Stack

The toolkit.

iOS

  • SwiftUI
  • Swift Concurrency
  • LocalAuthentication
  • CryptoKit

Android

  • Jetpack Compose
  • Kotlin Coroutines
  • BiometricPrompt
  • StrongBox

Core & API

  • Rust
  • UniFFI
  • Axum
  • Postgres

Quality

  • XCTest
  • Paparazzi
  • proptest
  • Firebase Crashlytics
Next project — 03 / 03 Northwind Atlas Real-time logistics · Next.js + Rust