Aidan DavisHarmony
Full-stack engineer · web, mobile, and offline systems
I build software people use at work, end to end — field apps, office tools, sync, permissions, and the document pipelines underneath them.
About
I’m a full-stack engineer at RamRod Software, building inspection software for a housing business while I finish a CS degree at Swinburne. I’ve been there since 2022 and I own the whole stack.
Since 2025 I’ve been rebuilding the company’s toolchain from scratch. It’s a Convex, Next.js, and React Native monorepo, and about 1,100 of its 1,150 commits are mine. Three parts were hard: a multi-org permission model I had to design, not adopt, an offline sync layer that resolves conflicts without losing a day of field work, and a document compiler that turns a typed content model into the Typst PDFs clients get. None of those had a clean off-the-shelf answer.
Before the rebuild I maintained what it replaced: nineteen C# projects, three Office add-ins, and a Xamarin field app passing SQLite files between office and field with no central server. It taught me to reason about data consistency with no network to arbitrate, to make emitters injection-safe, and to write permission boundaries down rather than assume them.
Skills
- Primary
- TypeScriptC#ReactReact NativeNext.jsConvex
- Working
- .NETSQLitePowerSyncExpoBunZodTypstClerkAzureAzure OpenAIVSTOXamarinElysiaEffectDaytona
- Familiar
- BlazorAuth0PGlitelibSQLDrizzle
Experience
- RamRod Software Pty Ltd 2022 — present
Full-stack engineer — principal author of the current inspection platform
Education
- Swinburne University of Technology expected 2028
Bachelor of Computer Science, in progress
Selected work
Gus the inspection platform
Gus Highlights
- Written on site
- Inspectors capture as they inspect, so hours of report writing left the working day.
- One system
- Three Office add-ins, a field app, and a file share collapsed into one place to look.
- In daily use
- Darbecca’s inspectors and office staff run every job through it, booking to delivery.
- Records came across
- Two decades of legacy records migrated in, so nothing had to be re-keyed by hand.
- Principal author
- I wrote 1,100 of 1,150 commits, about 372,000 lines across fifteen packages.
- Backend scale
- 131 tables, 304 indexes, and 452 functions behind one web app and one field client.
Stack: Convex · Next.js · React Native · Clerk · TypeScript · Bun
Parts of Gus
Choosing the infrastructure
- Failed early
- Two stacks were proven unfit before either could become the thing to maintain.
- Sync, not ORM
- Testing Postgres offline is why the platform runs on a sync engine that survives no signal.
- Nothing shipped open
- Permissions landed before the screens they protect, so no release went out unguarded.
- Decisions kept
- Every rejected stack still runs from git, so the choice can be re-argued, not just asserted.
- First attempt
- A 2024 Blazor Server prototype answered the domain questions and lost on delivery.
- Second attempt
- The 2025 Next.js and Convex attempt reached 101 commits and 23 tables before it was cut.
Stack: Blazor · Auth0 · PGlite · libSQL · Drizzle · Convex
Typed document compiler
- Vendor removed
- The business stopped paying a third party to render the reports it sends clients.
- No re-typing
- The report compiles from what the inspector captured, so nobody re-keys it in the office.
- No broken reports
- User text can’t become document syntax, so a defect note can’t corrupt a client’s PDF.
- Signed rendering
- Rendering requests are signed and fail closed, so nothing renders on the service’s behalf.
- Editor stays out
- Editor state never reaches the document package, so an editor change can’t break old reports.
- Two formats
- One model produces both the PDF a client reads and the DOCX the office edits.
Stack: Typst · Zod · Bun · Elysia · Effect · TypeScript
Offline field capture
- Hostile sites
- Buildings with no reception and whole disconnected days still produce a finished report.
- Evidence survives
- Photos that can’t be retaken survive dropped connections without duplicating or vanishing.
- Conflicts are visible
- Conflicts and tombstones are records, so a bad merge can be read rather than guessed at.
- Sync we control
- Running the sync tier in-house makes an outage ours to fix rather than a vendor’s to schedule.
- On-device data
- A subset of the backend streams into on-device SQLite, so the app works with no signal.
- Day-end reconcile
- A full day of offline edits reconciles once the inspector has signal again.
Stack: PowerSync · SQLite · React Native · Expo · Convex
In-house agent runtime
- Same permissions
- Agents resolve through the same access rules as people, so nothing gains reach by automating.
- Sandboxed work
- Each thread runs real commands in its own sandbox, with results tracked as data.
- Built in
- The runtime lives inside the product, so it reads the same records everyone else does.
- Runtime scale
- About 22,900 lines of agent runtime, with threads forming an explicit delegation tree.
Stack: Convex · Azure OpenAI · Daytona · React Native · TypeScript
Database I/O reduction
- Bill traced
- One query was consuming 74 GB against a 50 GB monthly database budget.
- Hidden rows found
- A pagination bug that could silently skip records between pages surfaced and was fixed.
- Measured first
- Per-function bandwidth found the cost before anything was changed on a hunch.
- Cause documented
- Duplicate subscriptions, relation fanout, and invalidation were written up, not guessed.
Stack: Convex · React · TypeScript
Office and SQLite transport what Gus replaced
Highlights
- Kept it running
- Nineteen C# projects stayed live daily while their replacement was built alongside.
- Failures got visible
- Crash and usage telemetry turned a silent field app into one the business could debug.
- Reports stayed right
- A wrong report comes from a bad merge, so correctness there was the whole job.
- Office automation
- Word and Outlook generated and delivered reports without anyone re-typing them.
- Notes on photos
- Inspectors could annotate evidence on site, delivered across schema, capture, sync, and upload.
- Nineteen projects
- Nineteen C# projects, about 84,000 lines, across seven .NET target frameworks since 2019.
Stack: C# · .NET · VSTO · Xamarin · SQLite · Azure Files