Work Experience

Associate Software Engineer at Canonical. Before that, production systems across frontend, backend and cloud infrastructure at SONIQ Digital and CSIRO.

Associate Software EngineerCurrent

Nov 2026 — Present

Canonical · Melbourne, VIC (Remote)

Work on the Snap Store, Canonical's app store for Linux software packaged as snaps, in the SaaS Engineering organisation.

Junior Software Engineer

Feb 2026 — Oct 2026

SONIQ Digital · Richmond, VIC

Built the React frontend and the event-driven backend microservices behind a live digital signage and content management platform (CMS), sold as a SaaS product and running on AWS.

Highlights

  • Re-architected the transactional-outbox pipeline across three environments, replacing a managed DMS → Kinesis → Lambda fan-out with a small poller running on each microservice's already-underused Fargate task that publishes straight to EventBridge. This removed the DMS and Kinesis spend entirely (about 40% of the combined bill across three environments) and cut production cost by 26% in the first full month.
  • Found the cause of a six-week RDS cost regression that doubled dev Aurora Serverless spend: a once-per-second ORDER BY created_at claim query was scanning a bloated 1.7 GB outbox table with no index to help it. Implemented a composite (created_at, id) index as a schema migration to solve it, and reclaimed the bloated table from 1.7 GB to 24 kB.
  • Built a TypeScript CLI to move customers off a legacy CMS one account at a time. It pulls media, templates, campaigns and schedules through Playwright (skipping expired schedules), recreates them through the new platform's APIs, and can dry-run, verify and roll back each load. On staging it moved enterprise accounts with 8 to 10 GB of media in about an hour each, and 189 Vitest tests cover it.
  • Carried out the step-by-step migration of four backend microservices to Go against one shared OpenAPI contract, with the engineer who initiated it: mapped each service's architecture onto Go layers in written plans, a v1-to-v2 route map and agent context for AI-assisted development, then completed the device service (28 operations) as the template the other three copy, with media (42 operations) in progress.
  • Cut staging costs by 30% and development costs by ~15%, by building an event-driven scheduling service (AWS Lambda + EventBridge) that shuts non-production environments down overnight and at weekends, and by fixing a cron bug that had left dev running every weekend.
Cloud cost and infrastructure4
  • Consolidated three copies of the outbox poller that had drifted apart into one versioned shared package used by four microservices, finishing the transactional-outbox teardown, and added per-environment Fargate task sizing so dev and staging tasks dropped to the smallest size while production kept its capacity.
  • Worked hands-on in AWS infrastructure as code across three systems: wrote the environment scheduler (Lambda + EventBridge) as its own CDK stack, wrote the Terraform for the Shopify integration's EventBridge resources, and tore down the CDK stacks behind a retired DMS → Kinesis pipeline.
  • Unblocked a large TypeScript migration (.js → .ts, .jsx → .tsx) that made the codebase type-safe and easier to maintain, by mapping and diagramming the existing AWS infrastructure and how each service talks to the others.
  • Routed user inquiries and notifications straight into HubSpot CRM with a serverless AWS Lambda service, taking manual handling out of the customer feedback loop.
Backend, Go and integrations6
  • Made the API contract a compile-time check in the Go migration by generating server interfaces and a typed test client from the OpenAPI spec (ogen) and the data layer from SQL (sqlc), so a missing handler fails the build, and wrote an architecture checker that rejects any handler shipped without a test.
  • Wired Shopify webhooks into internal microservices (EventBridge + SQS) so a hardware purchase activates a CMS trial on its own, with no manual setup between buying the device and using the software.
  • Built the Stripe trial activation flow in the billing service so customers can start a Business Tier trial without entering card details, using deterministic idempotency keys to stop a duplicate Stripe customer being created between signup and activation.
  • Migrated device communication onto a cloud-native synchronisation service, so data syncs reliably in real time across distributed signage displays and more displays can be added.
  • Aligned free-tier limits across distributed microservices, by fixing entitlement checks that disagreed with each other from service to service.
  • Automated 4K-to-Full-HD transcoding for a legacy CMS by building a media pipeline, so client uploads play back correctly and less video data ships to each site.
Frontend architecture and design system9
  • Led a TypeScript migration that gave a React frontend strict type-safe boundaries and one clear path for data, by standardising core Context providers (authentication, theme, layout) for shared state and setting a layered data flow (DTO → mapper → domain → API → TanStack → state hook).
  • Reduced a backend contract change to a one-place edit instead of scattered fixes across every feature, by generating TypeScript types from four microservices' live OpenAPI specs and grouping DTO mappers, typed API functions and TanStack hooks into per-service shared modules.
  • Standardised how the UI looks and behaves across the codebase with a design-system layer: Apple-inspired semantic type and colour tokens, fixed control and icon sizes via CVA, shared presentational primitives (Badge, EmptyState, StatusDot, list shell), and form layout components (Field, Stack).
  • Led a production React codebase's move off ad-hoc styling onto a central token system by writing a custom check-styling lint guard, shipping it advisory-first with an allowlist so CI stayed green, then stripping inline styles, raw hex colours and arbitrary pixel utilities feature by feature. The migration built consensus rather than finishing outright, with adoption speeding up as more base components landed and each new one cut the friction for the next.
  • Moved 10+ pages of a production React app (billing, devices, media, schedule editor and others) onto shared base components one page per PR, replacing ad-hoc definitions and pruning over 1,000 raw-colour lint suppressions, and extracted a new shared component only when a page showed a third call site.
  • Merged two parallel React component libraries into one barrel-exported hierarchy (primitives / composites / dialogs), retiring six duplicated components across ~80 files in small steps that changed no behaviour, and locked the layering in as ESLint rules raised from warning to error once the last compatibility shim was deleted.
  • Rebuilt several web pages mobile-first with reusable UI patterns, so they work on any screen size and no longer carry duplicated CSS.
  • Added layout support for portrait (1080×1920) and landscape (1920×1080) screens, so signage renders correctly in both orientations customers mount displays in.
  • Reworked a client-facing hospital directory app (AWS Amplify) for readability and touch use: applied WCAG colour-contrast rules, added alternating row colours, standardised type and spacing across multi-level directory views, and added touch affordances, all shaped by rounds of client and management feedback.
Product features6
  • Turned a Shopify hardware purchase into an active CMS Business Tier trial in one email-driven step, by building the claim page and the flow behind it: token validation, authentication round-trips, account eligibility checks and trial confirmation UI. Deployed to the development environment.
  • Shipped device grouping end to end, so users can filter and manage devices in bulk by group, by adding a group field to the FastAPI data model, building group CRUD and bulk assign/unassign APIs, and building the React UI: a group filter rail, colour-coded chips, contextual action bars, multi-select, and a React Table device grid.
  • Kept screens from going blank when schedules overlap or run out, by replacing server-side conflict checking with priority-based playback resolution and a per-schedule fallback field (FastAPI), and building the schedule editor UI: priority selector, fallback-create prompt with an explanatory banner, and a soft warning on overlapping events.
  • Designed and built the frontend for a two-tier tenancy feature separating organisations (groups of people) from workspaces (groups of resources), after pairing with a teammate on requirements and domain modelling to turn an open-ended product concept into a defined scope.
  • Reworked the schedule editor's week view so events can be dragged and resized directly on the calendar grid instead of only through the event dialog.
  • Diagnosed an N+1 request pattern on the media root and dashboard: 14 folders triggered 15 requests, and one end-to-end test spent 75s across 28 requests. Fixed it by replacing whole-library fetching with per-directory and per-ID reads, and cut a redundant per-folder mediaCount request. Rebuilt the page as a Drive-style browser (unified New menu, sortable table, type-filtered grid, root-level uploads), then brought back account-wide browsing by content type as an explicit opt-in mode instead of the old first-load fan-out.
Debugging and reliability4
  • Caught a silently broken customer activation flow in the development environment before it reached production, by tracing CloudWatch logs across the billing and IAM microservices to a renamed event topic that had cut a service's subscription, then got event-topic renames treated as a breaking change that needs explicit versioning.
  • Found why 30 of 1,153 videos stayed stuck in processing during a staging migration: upload bursts throttled an endpoint lookup that the media worker never cached. Traced it through the dead-letter queue, MediaConvert jobs and worker logs, filed the cause with a proposed fix, and paced uploads with crash recovery so the migration could keep going.
  • Fixed a production bug where switching on monthly recurrence made timeline events disappear, by reproducing it with targeted tests and correcting timezone-sensitive scheduling logic, then added those tests to the CI/CD pipeline so it cannot come back unnoticed.
  • Cleared production issues as QA reported them across billing, scheduling and configuration screens (entitlement values disagreeing across widgets, missing form validation, an unsurfaced tier-downgrade rejection), keeping live deployments stable and the UI predictable for customers.
Collaboration and delivery5
  • Scoped features with product managers and engineers before any code was written, agreeing requirements, user workflows and edge cases so work spanning several microservices started from one shared spec.
  • Converted a vague request into a written spec before any code was written, by running a discovery phase with the managing director and the engineering team on the business context, the scope and the UX limits of a Shopify-to-CMS trial activation system.
  • Documented the architecture of a large microservice system in writing and diagrams, capturing the service flows and design patterns that until then lived only in people's heads, so new engineers could get up to speed on their own.
  • Split large Jira epics into small tasks that each ship on their own, making team progress visible week to week and letting work land continuously instead of in one lump.
  • Translated decisions from engineering discussions into PR-ready plans with ordered Jira tasks and delivery dates, using Claude Code with Jira MCP connectors, so the reasoning behind each decision stayed attached to the work.
TypeScriptReactTailwind CSSViteNestJSPython (FastAPI)GoPostgreSQL (Aurora)AWSAWS CDKTerraformDockerPlaywrightVitestGitCI/CD (GitHub Actions)

Software Engineering Intern / Casual Software Engineer

Mar 2024 — Jun 2025

CSIRO · Clayton, VIC

Architected and delivered a production lab automation system for a group of research scientists, combining real-time telemetry, firmware control and secure login, so experiments once run by hand now run automated and logged. Built within a multi-disciplinary engineering team.

Highlights

  • Enabled remote hardware control and live monitoring in a production laboratory, by leading full-stack development across a Vue/Nuxt frontend, Node-based services, a firmware interface, and SQL/InfluxDB databases.
  • Designed a configuration-driven firmware abstraction layer (UI → server → firmware → Modbus hardware) that replaced hard-wired single-device bindings, so new multi-column hardware setups need a configuration change, not a refactor.
  • Implemented safe, correct lock mechanisms to prevent concurrent access to the hardware and firmware-level caching to minimise hardware interference, contributing to stable three-month continuous production operation in a live laboratory setting.
  • Integrated real-time InfluxDB telemetry with dynamic ECharts visualisations and WebSocket updates via custom SVG components, enabling efficient time-range filtering and accurate experiment monitoring without page reload.
  • Led the UI/UX redesign and domain analysis for a real-time refinery operations platform, translating operator requirements into a mobile-first React Native prototype to optimise industrial workflows and on-site monitoring.
Architecture and backend6
  • Chose to invest in a reusable, configuration-driven hardware interface over a faster hardcoded API when a second control-box configuration arrived, trading longer initial delivery for unblocking the team's electronics engineer to continue R&D on the control box without repeat rework.
  • Applied OOP principles (inheritance and abstraction) to reuse hardware communication logic and extend software classes for different hardware configurations, improving scalability across multiple control systems.
  • Redesigned and normalised the relational schema to model experiment lifecycles, user roles and versioned comments, giving the lab an audit trail of comment edits on every experiment.
  • Kept the system stable through iterative production use in a live laboratory by refining the API design, introducing structured logging and adding defensive error handling.
  • Implemented Azure Entra ID SSO and middleware-based role authorisation to enforce secure access control across the application, aligning the platform with institutional security standards.
  • Containerised services using Docker and deployed to CSIRO's internal hosting environment via SSH, for reproducible builds and consistent runtime configuration.
Frontend and UX4
  • Refactored a large Vue.js frontend into a structure a fellow engineer commended for its maintainability and developer experience, by enforcing a presentational/container pattern that isolated API logic to page-level components and kept UI components pure and prop-driven.
  • Made the web and mobile interfaces more accessible and consistent by adding ARIA labels, enforcing colour-contrast standards, and standardising typography, component styles and interactive patterns.
  • Designed a Figma prototype with variable-driven state management and dynamic view transitions to distil the most operationally critical data from an existing desktop system into a mobile-first interface for operators working in a constrained, hazardous on-site environment, clarifying scope and aligning the industry partner on layout and data load before React Native development began.
  • Conducted structured evaluation of cross-platform technologies (Flutter, .NET MAUI, React Native), guiding architectural decisions based on performance, maintainability, and alignment with the existing tech stacks.
Delivery and communication4
  • Ran the project through the full SDLC (requirements analysis, iterative prototypes, Jira tracking, Git, formal SRS/SDD documents, commissioning support and knowledge transfer) so the lab could maintain the system after handover.
  • Worked with researchers, electronics engineers and external vendors to match software behaviour to hardware capabilities, supporting commissioning and a safe handover of the laboratory.
  • Led technical demonstrations for internal leadership, visiting industry partners and national intern cohorts, explaining the system's architecture decisions and what applied software engineering adds to mineral processing research.
  • Produced a handover suite at system completion: SRS/SDD documentation from frontend to backend, UML architecture diagrams used to brief a mechatronics engineer who will onboard future developers, and a step-by-step deployment tutorial co-recorded with the team lead, so the system can be rebuilt end to end.
“It stimulated a great conversation at lunch about how compelling the solution is as well as the value of the great voice of customer work and how the user interfaces address the changing way people work.”
Research Director, CSIRO
Python (Flask, threading)JavaScript/TypeScript (Vue, Nuxt, Node)React NativeTailwind CSSPostgreSQLInfluxDBModbusDocker ComposeGit/GitHubLinuxAzure Entra ID (SSO)EChartsWebSockets