Ivan – Flutter, Golang, Node.js

Rhumb is a marine navigation app for iPhone and Android, aimed at recreational skippers who are still learning to navigate (RYA Day Skipper level and below). It opens straight to a worldwide vector sea chart with OpenSeaMap seamarks and works out of the box, with no account and no chart downloads, while competitors in this space (Navionics, Savvy Navvy, Orca) sell charts region by region. The free tier gives live position, COG and SOG, a dividers tool for rhumb-line distance and bearing, and markers synced through the user's own iCloud. Rhumb Premium adds auto-routing that plans a passage around land. A second one-time-purchase app, Rhumb Instruments, shares the same instrument stack.

Both apps are in production on the App Store and Google Play, running on a self-hosted vector tile pipeline and a Cloudflare Workers API. Live at rhumbapp.com. Built solo in six weeks on a spec-driven, AI-assisted workflow: roughly 580 commits, 7,000 lines of Swift and 9,000 lines of Kotlin.

• Built the native iOS app in Swift and SwiftUI and the native Android app in Kotlin with Material 3, each written against its own platform SDK so the app stays reliable and battery-efficient offshore.
• Implemented the chart renderer on MapLibre Native, solving layer z-order re-stacking, style reloads that wipe imperative layers, and hold-then-drag gestures that coexist with camera follow and pinch-to-zoom.
• Wrote the navigation maths and formatting layer: loxodrome distance and bearing, GPS smoothing, SOG averaging, and RYA-correct handling of heading, bearing and course with degrees true, knots and nautical miles throughout.
• Replaced the third-party basemap with a self-hosted vector tile stack: a Protomaps planet mirror plus a Planetiler seamark build in Cloudflare R2, served by a Workers tile server with its own sprite and glyph pipeline and a quarterly refresh runbook.
• Built the API as a TypeScript Cloudflare Worker: an auto-routing proxy authenticated by Apple App Attest on iOS and Google Play Integrity on Android.
• Shipped the paid tier with StoreKit 2 and Play Billing 8, and automated releases for four store listings with XcodeGen and Fastlane, including framed screenshot generation.
• Ran the project on a spec-driven, AI-assisted workflow: every feature starts as a written design spec and implementation plan, Claude Code writes most of the code, and I own the architecture, review and marine correctness. Acted as product owner throughout, from pricing to both store submissions.

auto-sea-way is an open source maritime auto-routing engine that computes realistic sea routes between any two coordinates, for teams building fleet tracking, voyage planning and logistics tools. It ships as a single Rust binary plus a graph file, so a team can self-host the whole thing.

The routing graph is generated from OpenStreetMap land polygons using H3 hexagonal indexing at adaptive resolution: coarse cells in open ocean, fine cells along shorelines, and res-13 corridors through passages such as Suez and Panama, which is what makes a canal transit navigable at all. The full planet graph holds 39.4M navigable cells and 299.5M edges in a 717 MB file and builds in about five hours on a 32-core machine. At query time A* runs over a pre-allocated buffer pool; short routes return in under a millisecond and a 3,000 nm North Atlantic crossing takes about a second.

In production at v0.6.1 with multi-arch Docker images, pre-built binaries and a key-authenticated HTTP API, dual-licensed MIT and Apache-2.0. Roughly 9,500 lines of Rust across five crates, shipped solo in four months on a spec-first workflow with Claude Code (246 commits, 13 design documents).

• Designed and built the entire system solo across five Rust crates: graph structures and A* routing, the shapefile-to-H3 build pipeline, the axum HTTP API, cloud build orchestration and the CLI.
• Implemented the adaptive H3 resolution cascade and cell classification with hierarchical parent-cell elimination against an R-tree, turning ~900 MB of OSM land polygons into a fully connected 39.4M-node graph.
• Fixed antimeridian handling across the pipeline, removing false land classification around the date line and 433K spurious nodes near the Bering Strait, Fiji and the Chukchi Sea.
• Cut per-request cost at planet scale: replaced a full-graph memset (~358 MB of writes per request) with an O(1) generation-counter reset and moved route computation onto tokio spawn_blocking, so long routes stopped stalling health probes.
• Owned release and distribution: CI with fmt, clippy, test and license gates, multi-arch Docker images on ghcr.io, tagged binary releases, and a 20-route benchmark harness used as the regression gate on every routing change.
• Owned the product decisions: API surface and key-auth model, the self-hosting story, dual MIT / Apache-2.0 licensing, and a shore-clearance feature driven by an outside user's issue report.

Brollr is a native iOS and iPadOS app for contributors to BlackBox Global, a stock footage marketplace with a strict technical spec: a constant frame rate from a fixed list, no audio track, 5 to 59 seconds, and specific resolutions and size ceilings. Most iPhone footage fails on frame rate alone, because iOS records at a variable rate by default. Brollr runs the whole pass on the phone: import, trim, frame-rate conversion, audio stripping, export at accepted specs and batch FTP upload to the portal.

Two paid steps sit on top: AI keywording, where Gemini watches the clip and returns title, description, keywords and filename through a faceted prompt with server-side normalisation and KV caching, and CSV metadata export in the exact format the portal ingests. Subscriptions at $4.99 and $9.99 a month raise a free monthly credit ceiling.

Live on the App Store since April 2026, currently at version 1.3.5. Built solo in six months with Claude Code as the primary development method: 477 commits and roughly 90,000 lines, with zero third-party dependencies in the client.

• Built the SwiftUI client with MVVM, @Observable state and SwiftData persistence, targeting iOS 18 and shipping with zero third-party dependencies.
• Owned the AVFoundation video pipeline: frame-accurate trimming, codec selection across H.264, HEVC and ProRes 422, audio stripping, HDR tone mapping, and constant-frame-rate re-encoding that models NTSC and integer frame-rate families separately, so a 59.94 fps source is only ever slowed to 29.97.
• Designed and built the AI keywording backend as a TypeScript Cloudflare Worker: resumable upload into the Gemini Files API, a faceted system instruction returning one JSON object, and a server-side normalisation layer that de-duplicates, collapses near-synonyms and clamps every field to portal limits, pinned by a vitest suite.
• Built the cost and correctness controls around that pipeline: a Workers KV cache keyed on video SHA-256 with a 28-day TTL, a guard against Gemini file expiry, and a shared compile-time pipeline version that invalidates stale entries when the prompt changes.
• Locked the backend to genuine app installs with Apple App Attest, implementing CBOR and ASN.1 decoders from scratch for the Workers runtime, and built the FTP-over-TLS uploader as a Swift actor with credentials in the Keychain.
• Shipped StoreKit 2 subscriptions with a credit-based entitlement model and server-resolved entitlements, and set up CI and release automation with Fastlane and GitHub Actions.
• Ran the product side as owner: pricing and packaging, the marketing site at brollr.app, App Store listing copy and a paid acquisition smoke test.

Yacht Cabin is a peer-to-peer marketplace for sailing berths: a boat owner posts a planned passage and opens the individual cabins on it, and a traveller books a single berth on a boat that is already heading their way. Live on the App Store and Google Play, serving a community of more than 15,000 sailors. The company was accepted into IFB Hamburg's InnoFounder programme in March 2025.

The product is three applications over one backend: a Flutter app on iOS and Android for the whole booking experience, a Next.js site for public trip discovery and SEO, and an Nhost stack with Hasura GraphQL over PostgreSQL and TypeScript serverless functions. Trips are modelled as multi-leg passages, so availability, pricing and confirmation resolve per berth per leg. Most of the correctness lives in PostgreSQL: roughly 70 stored functions and 45 triggers across 288 migrations over 91 tables, exposed through Hasura with row-level permissions, so a berth can only be double-booked if the database itself allows it. Around that sit in-app messaging with video calls, paid ID verification, Stripe payments with escrow deposits, reviews and a clustered world map of live trips.

Built by hand for its first two years, then switched to spec-driven AI-assisted development in March 2026. Daily output roughly tripled (282 commits in the five months before the switch, 794 in the four months after), delivering escrow, business accounts, paid KYC, the nautical routing subsystem and a full freemium repricing.

• Built and shipped the Flutter iOS and Android app end to end: Clean Architecture with Riverpod and GoRouter, around 47,500 hand-written Dart lines across 641 files.
• Designed the PostgreSQL domain model behind the marketplace: 91 tables, 288 migrations, roughly 70 stored functions and 45 triggers covering berth availability, price rollups, booking state machines and an append-only event log.
• Exposed the schema through Hasura with four roles and row-level permissions, and generated typed GraphQL clients for Dart and TypeScript so a schema change surfaces as a compile error before it reaches a user.
• Integrated Stripe across the whole money path: Connect Express onboarding for business accounts, escrow deposits released by a nightly job, per-booking service fees and webhook handling, backed by 25 TypeScript serverless functions with Vitest tests on the state-transition logic.
• Built the map experience on flutter_map with marker clustering and server-computed nautical routes cached per passage plan, and shipped the Next.js public site with a paginated trip sitemap and universal links.
• Diagnosed and vendored a patched Stripe Android SDK to clear a duplicate-class conflict with the Jitsi Meet SDK that was blocking Android release builds.
• Owned the product side as co-founder: pricing and the freemium pivot, feature scope, store submissions and review responses, and the investor data room.
• Moved the project to a spec-driven AI-assisted loop in March 2026: design spec and implementation plan per feature, Claude Code implementing against the plan, and diff review back against the spec. Daily commit output roughly tripled, and the four months after the switch delivered escrow, business accounts, paid KYC and the freemium release.

A cross-platform mobile platform for field crews doing inspections, compliance forms, site sign-on and asset checks in places with no reliable mobile signal, used by security, agriculture and industrial operators across Australia. Server-defined dynamic forms drive the product: sixteen question types covering signature capture, defect logging with photos, barcode scanning, GPS stamping and on-device text extraction from chemical labels. The product is multi-tenant: theming and terminology come from the backend, and one shared library feeds three sibling branded apps.

The engineering centre of gravity is offline correctness: the local database is the single source of truth, the interface never waits on the network, and a pending write queue classifies failures, caps retries and rewrites temporary record ids once the server issues real ones. Roughly 22,500 hand-written lines of Dart across 14 modules, covered by 115 tests. Shipped on the App Store and Google Play across three environments.

• Designed the offline-first engine with a pending queue that classifies failures as terminal or transient and caps retries, so non-idempotent submissions stopped producing duplicate server records.
• Refactored a single 8,200-line application into a shared core library plus thin app shells behind a config abstraction; a new vertical app for a different customer segment was scaffolded and running in one working day.
• Grew the codebase 2.7 times and test coverage from a single test file to 115 tests in nine months, by running around 40 written implementation specs through coding agents while personally owning authentication, sync, encryption and queue correctness.
• Automated App Store and Google Play screenshot capture in CI across four device classes, removing a manual per-release chore that previously took an afternoon.
• Shipped six release lanes, three flavours across two platforms, through Fastlane and GitHub Actions with automatic version bump, Play upload-key signing and store drafts staged for human review.
• Added on-device machine learning for chemical label reading, so field users capture active constituent, solvent and group with the camera instead of typing them.

A tablet and phone app for board members and executives preparing for meetings: a calendar, meeting detail with agenda items and attached papers, and a dashboard that also renders as a home-screen widget. Documents are the heart of it. Papers download in the background, are encrypted at rest and decrypt only to a temporary path while open; members annotate them in an in-house PDF engine, keep private bookmarks and email flattened copies. Server-driven forms, push notifications, multiple profiles, and a PIN and biometric lock complete it.

The interesting engineering is reliability under bad conditions: every repository falls back to local data when connectivity drops, an ordered eight-step sync chain runs the same way every time, and two offline outboxes hold queued email shares and unsent form submissions so a server refresh cannot overwrite work that has not left the device. Around 14,100 hand-written lines of Dart plus 4,000 lines of tests, built on Clean Architecture. Released to the App Store and Google Play.

• Built encryption at rest for every downloaded paper using authenticated encryption with a custom container format, so board papers on a lost device are unreadable outside the app.
• Moved downloads onto a background transfer service so annotating a paper, killing the app and relaunching still leaves the annotation saved and queued for upload.
• Root-caused a token rotation race between the background download isolate and the main isolate, fixing it with single-flight refresh, a cross-isolate guard and escalation to a re-authentication sheet.
• Designed the eight-step sync chain with two offline outboxes, one for queued email shares and one for form submissions with provisional ids, so a server refetch never clobbers unsent work.
• Ran the store releases end to end, with committed localised metadata and screenshots generated in CI.

An enterprise document product delivered in two phases for the same client. Phase one replaced a licensed commercial PDF SDK with an in-house viewing and annotation engine for Flutter: seven annotation types with text snapping, drag and edit, undo and redo, private bookmarks, in-document search, XFDF interchange between platforms, and on-device document summarisation. iOS builds on Apple's PDF framework. Android had no annotation support in the open-source renderer, so hit testing, drawing, gesture routing and the undo stack were written from scratch.

Phase two rewrote the four-module host app in native Swift 6 and SwiftUI on iOS 18, reusing the annotation engine. Nine specification documents totalling 1,300 lines were written before any code: thirteen numbered architecture decisions with rejected alternatives, per-screen behaviour specs, a data model mapping and a phased plan with exit criteria. Coding agents executed the specs in parallel branches while every change to authentication, encryption and sync was gated on manual review.

Combined delivery: around 26,000 lines of Dart, Swift and Kotlin in the engine plus 33,200 lines of Swift in the rewrite, 335 native engine tests and 674 rewrite tests, with behaviour parity validated against the previous build running side by side.

• Replaced a licensed commercial PDF SDK with an in-house engine, removing recurring per-seat licence cost and giving the product full control of the annotation model and file format.
• Built the entire Android annotation layer in one month against a render-only rasteriser: hit testing, drawing, a gesture router multiplexing pan, zoom, draw, drag and select, and an undo stack matching the iOS semantics.
• Achieved XFDF round-trip parity across platforms after finding freehand strokes serialised in two incompatible dialects, adding per-gesture dialect detection covered by fixture-based tests over all seven annotation types.
• Added on-device document summarisation using the platform local model, with map-reduce chunking, language detection across 23 languages and prompt-injection sanitisation tests.
• Wrote the full migration package for the native rewrite before any code: thirteen numbered architecture decisions recording rejected alternatives, per-screen behaviour specs, a data model mapping, the API contract and a phased plan with exit criteria per phase.
• Delivered the rewrite in ten active development days across 215 commits, 94 percent executed through agent sessions against those specifications, gating authentication, encryption and sync changes on manual review.
• Replaced hand-written response models with types generated from the backend OpenAPI specification at build time, and rebuilt file transfer as a background-capable session actor with a database-backed task registry.
• Root-caused 51 inherited failing tests in the reused PDF core to a gap in a test double, lifted the quarantine at 200 of 200 passing, and enforced one green CI gate covering build, both test suites and two linters.

A web and mobile development agency serving small and mid-sized businesses in Europe and North America, working through Upwork and direct referral. Over thirteen years it delivered more than 1300 projects: WordPress and WooCommerce builds, custom PHP and Zend Framework applications, e-commerce migrations, Node.js and React web applications, React Native and native mobile apps, and later Go microservices over RabbitMQ.

I co-founded it and split my time between running the business (client acquisition, pricing, contracts and the administration of a distributed team that grew to 25 developers) and engineering: hiring, mentoring, architecture review and rescue work on troubled projects. Thirteen years of moving between client stacks is where I learned to read unfamiliar code quickly and judge whether it is sound, the same judgement I apply now when reviewing code written by AI agents.

• Co-founded and ran the agency for thirteen years, owning pricing, estimation, client scoping, contracts and the operating budget.
• Ran the engineering hiring pipeline end to end and personally interviewed every developer candidate, growing the team to 25 engineers across PHP, JavaScript, Go and mobile.
• Set the architecture, code review and release standards applied across concurrent client projects, and mentored junior developers through their first production deployments.
• Served as the technical escalation point on troubled projects, taking over unfamiliar codebases mid-delivery and getting them shipped in whatever stack the client had committed to.
• Built the agency's shared delivery infrastructure: Dockerised environments, Docker Swarm deployment on self-hosted servers, CI/CD on GitLab, GitHub and Bitbucket, and internal tooling for scaffolding, deployment and reporting.
• Delivered 1300+ projects over the agency's lifetime, personally writing or reviewing code on a substantial share of them.