I make hard systems boring.

Light is an agentic accounting platform — an AI-native general ledger for companies operating across entities, countries and currencies. I work on the ledger’s reliability and the finance features built on it, and own work end to end, from customer conversations to production.

finance products

• Led intercompany invoicing end to end, from domain research and design to building every layer.
• Built three-way matching, with automatic bill-to-purchase-order matching and goods-receipt confirmation, designed with the customers who needed it.
• Shipped aged AP/AR reports, EU Sales List VAT reporting and non-calendar fiscal years.
• Cut failed bank payments from about 3% to near zero with automatic retries.

reliability and performance

• Root-caused and fixed three production incidents — a platform outage, connection-pool exhaustion and out-of-memory pod crashes — then added platform-wide safeguards so they don’t happen again.
• Reclaimed about 17.5 GB of unused indexes, moved heavy ledger reads to the read replica, and made large exports resumable background jobs.
• Made the integration test suite about 10x faster.

observability and AI engineering

• Set the team’s standards for AI tooling.
• Built an autonomous AI coding agent, including a code reviewer that reviewed 1,700+ PRs and prevented 45+ bugs, and a security agent that prevented 5+ vulnerabilities.
• Built Lucid, the repo’s docs and architecture decision record system, to spread knowledge beyond a few engineers, which helped new engineers onboard faster.
• Made Datadog metrics and alerts the team’s default in every PR.

I led technical development of a financial reconciliation platform for e-commerce businesses, from inception to production.

• Architected a multi-tenant platform processing millions of transactions monthly at 98%+ reconciliation accuracy across 5+ payment providers — Shopify, Klarna, PayPal, Plaid, Adyen.
• Built a four-tier dbt and Python pipeline (raw → staging → fact → app) behind transaction matching, multi-currency support and automated double-entry journals.
• Delivered the product across the React frontend, GraphQL API and NestJS backend.
• Established the engineering foundations — monorepo tooling, CI/CD to GCP, and a split transactional (PostgreSQL) / analytical (BigQuery) data architecture.

Formerly Flow Health. I led technical development of an AI-powered medical assistant for laboratories, physicians and insurers.

clinical and insurance products

• Built AI-assisted diagnosis and test recommendations, connecting medical knowledge with the clinical workflows physicians use.
• Delivered insurance claim-filing and fee-schedule workflows alongside the medical assistant.
• Integrated vector search into the medical knowledge graph on AWS OpenSearch, and built ingestion pipelines normalising unstructured medical histories so clinical information is searchable and usable in the product.
• Wrote embedded software streaming results off Sysmex lab analysers into the platform.

data platforms and reliability

• Recovered a completely lost production database — on the order of 1.5 billion records — by replaying events reconstructed from Kafka, CloudWatch and S3.
• Migrated the primary datastore from Cassandra to DynamoDB, improving availability and performance while cutting maintenance and cost by 90%.
• Introduced a graph database for relationship-heavy queries, cutting aggregation latency by 35%.
• Reworked data services to remove race conditions and ACL overhead, cutting latency a further 20%.
• Built real-time replication across databases.
• Set the team’s CI, code-standards and RFC practices.

I developed a web platform connecting doctors to medical events and conferences, refactored it end to end and optimised its performance.

• Optimised performance and bundle size down to a 1.7s Largest Contentful Paint, and added server-side rendering for SEO. I wrote up the approach in Optimizing website performance.
• Built the shared UI library that shortened new-view delivery, a web scraper enriching the platform with medical event data from multiple sources, and integrations for payments, analytics and marketing automation.

My first professional role. I built software digitalising client operations across legal, medical and laundry businesses.

• Accelerated product delivery with a reusable component library, plus reusable ERP modules and a library written in C#, increasing client capacity by 20% and revenue by 30%. Worked directly with clients to scope each delivery.

Four things I’m genuinely good at, with the evidence for each.

I started coding at 12, took my first paid job at 16, and have been doing this professionally for 10 years since.

I like being thrown at problems I don’t know how to solve yet — a medical knowledge graph one year, a Rust sync engine the next, an agent platform after that.

education

Bachelor of Science, Computer Science, 2018–2022.

languages

English, bilingual. Arabic, native.

Kin.app lets everyone claim what they ordered on a shared receipt. Tax and service charges follow the items, so nobody pays for a coffee they didn’t drink.

I designed the product, built the Kotlin backend, React Native app and AI features, and shipped it to the App Store and Google Play.

What I built

• Balances you can trace. A double-entry ledger records who owes whom and which debts each payment settles. Corrections reverse and repost transactions, preserving the history.
• An AI receipt reader at about 0.8¢ a scan. A small model reads the photo in a tool loop that crops, calculates and checks its own arithmetic, and a stronger model takes over when OCR and the small model disagree. It reaches 97% accuracy on 500 receipts in Latin and non-Latin scripts, across languages, tax rules and formats. Scans take about 9 seconds.
• A voice assistant. Live transcription turns what you say into a receipt, using the same permission-checked tools as the app.
• An MCP server for personal agents. Personal AI agents can read your receipts and balances.
• Fast item claiming. Reposting a receipt’s ledger transaction measured 104 ms p95 in k6 load tests against the real HTTP API.
• Fitness functions that govern AI-written code. More than 150 executable rules, an idea I took from Software Architecture: The Hard Parts, check source code, database schema, API routes and UI consistency, and fail the build when a change breaks one. They’re a big part of why code written with AI agents stays consistent. End-to-end tests exercise the app against a real backend.

Built with coding agents and reviewed line by line. I own the product decisions, architecture and release process.

Every local diff-review tool is read-only, so reviewing and git add end up as two passes over the same diff — you re-decide in the terminal what you decided five minutes ago in the viewer.

peel is one pass. Read a file, press s, and it’s staged, folded away, and the next file is in front of you.

• Staging is the review. Whole files only, so nothing writes the wrong lines into your index.
• Notes keep up with the code. Each comment freezes the file it was written against as a git object, so an edit above it moves the note with its line instead of stranding it on a number.
• Notes an agent can read. Comments go to JSON that Claude Code reads through a bundled skill.
• Read-only bases. --rev reviews further back than HEAD; --pr reviews a GitHub pull request from any checkout.

brew install ziadalzarka/tap/peel

This site borrows its interaction from peel — reading a file marks it off.

Generates keywords, titles, descriptions and OCR text for photos and videos, then writes the metadata back into Photos.app so the library becomes searchable. Built for a local model in LM Studio — your photos never leave the machine — but it speaks to any OpenAI-compatible API.

Photos.app ──▶ Discovery ──▶ Export ──▶ LLM ──▶ Writer ──▶ Photos.app
               osxphotos     Pillow     API     PhotoScript

Discovery finds media with no keywords. Export handles JPEG with HEIC and iCloud fallbacks, and pulls frames out of video via ffmpeg. The writer goes back in through AppleScript.

Notes from building software: connecting Go and Rust across an asynchronous boundary, and improving website performance.

Occasional explainers, usually about the layer underneath the thing everyone uses.

Tell me what the system does, what it’s doing wrong, and when you need it — that’s usually enough for me to say whether I’m the right person.