YumGott
Restaurant app with Swish payments, digital wallet, interactive reels and social features.
Passkeys instead of passwords. Idempotent, tamper-proof transactions. Real-time everything. I shipped a production crypto & fiat wallet end to end — and it's live on the App Store and Google Play right now.
Open to remote & relocation — Türkiye · EU Blue Card eligible · UAE
A working demo of intent hashing — the industry-standard pattern I use to tamper-proof money-moving flows. A canonical hash over the transaction fields binds every payment from prompt to execution. Sign it — then try tampering with it.
The intent is serialized deterministically — same fields, same order, every time.
SHA-256 fingerprints the exact intent the user approved. Real hash, computed in your browser.
Any mutation after signing — amount, recipient, path — produces a mismatch and the transaction dies.
…
Server-authoritative by default: the client displays and forwards — it never decides. The server recomputes this hash and rejects any mismatch before money moves.
Working simulations of the systems behind my payment work — transfers that survive dying networks, webhooks that heal themselves, transactions that survive an app kill, sockets that reconnect without missing a cent. All hand-coded, all running in your browser.
Pay on a dying network — get charged exactly once.
TX.IDEMPOTENCY 02 Webhook sagaKill the endpoint mid-payment and watch the incident heal itself.
BILLING.SAGA 03 Four ticks, zero liesAck-driven delivery states that survive a dead socket, in order.
RT.DELIVERY_STATE 04 Challenge–responseSign with a key that never leaves the phone. Replay it — get burned.
AUTH.CHALLENGE 05 Threat queueA debugger detection never waits behind heartbeats. Server enforces.
SEC.PIPELINE 06 Crash recoveryKill the app mid-transfer. The journal + one key = exactly one charge.
TX.LIFECYCLE 07 Socket resumeReconnect with a cursor — replay the gap, drop the dupes, to the cent.
NET.REALTIMEA cross-platform crypto & fiat wallet for a US fintech — deposits, withdrawals, transfers, exchange, buy/sell, and virtual & physical cards. I own the mobile side end to end: authentication, transaction safety, real-time, release engineering.
Complete passwordless system: passkey (WebAuthn/FIDO2) registration & login, OTP fallback via email / Google Authenticator, step-up re-auth for sensitive actions, per-device credential management with multi-OEM & iOS hardening.
Idempotency across every money-moving flow, plus payload-freeze snapshots, double-submit guards, and on-device transaction lifecycle tracking with persistence and crash recovery for in-flight transactions.
Intent hashing binds each payment to a canonical fingerprint that's rejected on any mismatch, tamper-protecting it from prompt to execution. (See the live demo above for how the pattern works.)
WebSocket layer with connectivity-aware reconnection; hardened Dio API stack with typed errors, encrypted requests, request signing, and strict logging hygiene — no tokens, balances, or PII.
Signed builds, secure keystore management, obfuscation with regression guards; co-owned iOS & Android store deployments and release sign-off with QA.
Spacing, color and typography tokens with full light/dark theming; centralized typed navigation; 7-locale i18n; bilingual (EN/中文) docs for an international team.
Not mockups — real systems under real constraints: a fintech wallet live on both stores, a multi-tenant SaaS in production, and client platforms owned from database to release.
A multi-tenant SaaS platform where the backend is the product — 27 bounded domains, 118 migrations, 1,570 tests — serving ranked, explainable B2B introductions with privacy enforced in the query layer, not the UI.
A query-layer bypass guard plus a dedicated isolation suite that fails the build on any cross-tenant read.
draft → paid → refunded, quotas that hard-block at the limit, and a Stripe webhook incident lifecycle that retries itself to recovery.
Root cause operational, not algorithmic — ranking runs had never executed. Fixed with debounced re-rank queueing on pool change.
Constant-202 magic links, hash_equals comparison, throttled endpoints — the API won't confirm an account exists.
Four client-only entitlement checks moved server-side; unknown keys now deny by default, with a tenant-wide AI budget cap.
Pint, Larastan L8 no baseline, Gitleaks and 1,570 tests — and I run the production deploys.
Not an app — a distributed system I designed and built solo across four codebases: a 109k-LOC Flutter client, a Laravel API that owns the truth, a Node.js real-time layer, and a Next.js moderation console. The hard part wasn't the screens — it was making location, presence and money-grade trust behave correctly across all four. Live on TestFlight, iOS & Android.
OS-level geofence regions wake the app on boundary crossings even when fully terminated — handling the iOS 20-region cap and asymmetric enter/exit registration to kill false "you left" events. The genuinely hard part of a location app, done right.
GPS only decides when to ask; the Laravel server decides inside/outside via Haversine and is the single source of truth. Every affirmative ping doubles as a presence refresh, and transient network errors never eject a user. Location integrity + anti-bot guards on top.
Clients emit over Socket.IO; the Node layer verifies identity against Laravel (no client-supplied identity is trusted) and fans out; Laravel persists and authorizes every event over a shared-secret internal bridge. Room membership is replayed on reconnect, preserving nested join order.
4-state WhatsApp-style delivery/read ticks driven by acks, typing & voice-recording presence, live polls, reactions, mentions, pinning, nested "flows", and timed "sprint" matchmaking — plus a custom-built voice-note UI with waveform scrubbing.
Two-path upload contract — presign → PUT → complete to S3 with a multipart fallback. Messages carry only a media_id; private objects are served via short-TTL signed URLs. Client-side compression before upload.
Next.js 16 admin: a live firehose room surgically patches React Query caches for live sprint/DM monitoring, a Leaflet map moderates bubbles in place, plus approval queues, RBAC tiers, warnings/bans, and a versioned legal-document CMS.
Cross-platform rental client — listings, media galleries, booking and payments — built from a single codebase for iOS and Android.
Live chat over the Pusher SDK, carrying delivery and read state through the message lifecycle rather than fire-and-forget sends.
Multiple payment gateways and third-party SDKs integrated behind a single checkout path, on Bloc + MVVM throughout.
A production Flutter app for Turkish tradesmen — quote in two minutes, invoice, chase the money. The hard part isn't the screens; it's that an usta works in a basement with no signal, so the whole thing is offline-first: every edit is a local op that reconciles against a Laravel 13 server which stays authoritative on conflict. Money is integer-minor end to end, PDFs are print-correct in Turkish and Arabic, and billing is gated by a server-verified entitlement.
Every mutation is an op in a durable local queue, applied optimistically and replayed when signal returns. Replay is idempotent (dedupe by op id) and the server wins conflicts by version — nothing is silently lost.
All amounts are integer minor units — no floats near money. The PDF, the list and the sync payload can never disagree because line and grand totals are computed once by a single pricing calculator and stored.
Real bidi text layout with hand-mirrored tables for RTL pages — after chasing a bug where Latin text reversed per character on Arabic pages (font fallback, not bidi). Three PDF templates, locale-aware money digits.
Entitlement comes from Laravel, not the RevenueCat SDK — one canonical billing identity bound to the account, so the free-tier gate (6th document/month) can't be spoofed by a client. Paywall trigger is attributed for the funnel.
Restaurant app with Swish payments, digital wallet, interactive reels and social features.
Flutter client plus a React admin panel, kept synchronized over Laravel APIs on one shared data contract.
Clean Architecture + BLoC with payments, role-based access and Arabic RTL — 95%+ code reuse.
Data showcase app for a charitable organization with validated form submission, responsive across devices.
Laravel 12 API (100 migrations, Services/Policies/Observers, policy-driven RBAC) plus a Node.js Socket.IO tier on a strictly Laravel-authoritative contract — the API persists, then fans out; clients emit only typing, presence and read acks, never state.
Containerised async Python agent: SQLAlchemy 2.0 over asyncpg and PostgreSQL 16, Alembic migrations as their own compose service, Pydantic v2 config, and httpx ingestion with tenacity retries and aiolimiter rate limiting.
Deterministic generation seeded purely from the calendar date, so every player worldwide gets byte-identical puzzles with no server, no accounts and no network calls — verified by an automated three-year forward sweep in CI.
Full store backend: product/variation/inventory CRUD, order tracking, auth and role-based admin dashboards.
I'm Saed — a senior Flutter engineer who found his edge where most mobile developers stop: the point where the app touches money. Payments punish sloppy engineering, so I build server-authoritative, idempotent, tamper-evident flows by default — then obsess over the design system, the animations and the i18n so it feels effortless to the user.
Before fintech I architected and led a four-codebase social platform solo — Flutter, Laravel, Node.js, Next.js — so I speak backend, infra and release engineering fluently, not just widgets.
I answer fast on WhatsApp and email. Remote-first, EU Blue Card eligible, open to UAE relocation — and I can walk you through any of this code, live.