What I do, and what backs it

I turn manual, error-prone processes into automations that keep running after I hand them over — and I am the one who finds out why the ones that stopped, stopped.

• Diagnosed why a payment provider kept rejecting a client's refund files and got 284 stranded refunds processed and paid, five days after first seeing the system.

• Built an email-driven voucher ingestion workflow confirmed still running fourteen months after delivery.

• Diagnosed an automation that had silently stopped sending, fixed it within a day of the report and wrote the root-cause note myself.

• Automated two manual data pipelines end to end as sole engineer, delivering 122.5 hours against a 130-hour budget.

• Hardened an inherited payment system in eight days so failed runs show red, bank rejections alert Teams and bad data is refused at intake.

I write the document the next engineer actually needs, and I write it for systems nobody wrote down the first time.

• Authored 36 knowledge-base pages at a September 2026 reading, about 90,600 words across 456 versions, drawing 4,388 all-time views inside the company.

• Authored 79 of 80 versions of a monitoring deployment guide across seventeen months, with 128 attachments the NOC ran from.

• Wrote the Service Desk procedure opened by 25 distinct colleagues, the widest readership of any page I authored there.

• Wrote both halves of a customer API programme in one week: the internal access-granting procedure and the only external-facing developer guide in the knowledge base.

I make two systems that were never meant to talk to each other agree, including on the path where money moves.

• Designed and shipped a bidirectional third-party to PSA integration in five days, processing 3,034 events in its first six.

• Sole backend developer for nine months on a consumer platform, owning the in-app purchase webhook, payment gateway and creator payout path.

• Built a usage-metering and tiered-billing pipeline on Azure that turns client API consumption into a PSA invoice line with no human step.

• Built a complete OAuth 2.0 pipeline from a third-party API into Dataverse in about 24 hours, still maintained a year later.

• Solved a provider that rotates its refresh token on every exchange, letting four flows share one credential without ever needing re-authorisation.

I build LLM systems that are grounded, auditable and cheap to run — deterministic where determinism belongs, and model-driven only where it earns its place.

• Built and operate an AI ticket intelligence pipeline over a live PSA, gating 2.1 million callback events so the model runs only on real change.

• Built a sentiment alerting loop that escalates negative tickets early, answered 108 times by the service desk across 761 notification runs.

• Forked an open-source MCP server and added per-member impersonation, Key Vault key storage and per-call auditing, live company-wide in three days.

• Replaced a six-tool chat agent with a deterministic query compiler, so the model never writes the query and never sees raw list output.

• Removed a class of hallucinated-identifier failures by grounding an agent in four deterministic entity resolvers instead of free-text queries.

I move production estates between platforms and land the count I rehearsed, without losing a cutover window. Rehearse, reconcile, then move once.

• Moved 83,722 Jira issues into a 2,000-seat enterprise tenant in a single production cutover.

• Migrated 133,331 Jira issues in 24 mapped batches after the vendor's own supported tool proved unusable.

• Consolidated two Atlassian estates into one Jira and Confluence Cloud organisation as sole delivery engineer across 3.5 months.

• Migrated a live 26-job monitoring platform off Azure Automation onto Container Apps with the legacy platform decommissioned six days after cutover, preserving every check and every notification wording.

• Migrated five internal Power Platform applications to React on Azure, so inherited tooling finally had source code that developers and AI agents could work on.

I own the production infrastructure our internal systems run on, end to end, and I size it to the constraint that actually binds.

• Proposed, built and operate the Azure platform every internal AI and integration system runs on.

• Built automated monthly secret rotation across 55 tenants that proves the new credential works before deleting the old one.

• Swept 62 managed tenants for app registrations still bound to a retiring Microsoft identity API and produced an 84-application remediation worklist.

• Designed and documented the delegated-administration model for a managed Microsoft 365 estate as five least-privilege GDAP role tiers.

I design access that holds up when someone leaves, when a secret expires, and when an auditor asks who did what.

• Replaced standing administrative privilege with request-and-approval elevation across directory roles, groups and Azure RBAC.

• Engineered credential-free multi-tenant access to client Microsoft 365 estates, so no client secret sits in the automation platform.

• Diagnosed a hybrid-identity failure where disabled cloud accounts silently re-enabled, and changed the control to disable in both directories.

• Built and operated monthly Entra ID credential-expiry reporting across 31 managed Microsoft 365 tenants for 26 months.

• Built an automated dormant-account deactivation control across a hybrid identity estate, reporting, warning and then disabling accounts inactive for 20 days.

I hold a whole delivery function on my own: scope it, estimate it, build it, deploy it, hand it over — and close it against the budget I quoted.

• Logged about 1,310 hours of real work across 45 organizations and 944 tickets as a sole software engineer.

• Scoped twenty-two client engagements for thirteen clients in one five-column statement-of-work format, eleven of which went on to delivery.

• Delivered three consecutive solo fixed-scope builds, roughly 265 hours in all, each closed within budget.

• Removed a licence purchase from a migration by sizing the real seat risk: 1,187 source users resolved to fewer than 60 that mattered.

• Proved a client's stated data requirement could not be met from the published source, then validated a defensible substitute three ways before building.

I am the engineer other engineers come to, and I bring new practice into a team by proving it works rather than by proposing it.

• Recorded by five engineers, in their own billed time notes, as the person they consulted on Python, PowerShell, FSLogix, AWS and deployment problems.

• Introduced Claude and AI-assisted development to an engineering team unprompted, then built the working method the team now develops with.

• Led delivery of a content platform across mobile, web and backend for 21 months, authoring 411 of 437 issues and 402 of 403 board items.

• Primary engineer on an enterprise migration delivered essentially on budget, personally delivering 93 of 126 hours while directing a three-person team.

• Mentored both developers who joined the team in 2026 on scoping, architecture and React standards.

I choose the architecture that the team left behind can actually operate, then write down why.

• Named by a colleague, in writing at a pre-project security session, as the architect of a project's stack rather than its implementer.

• Declared a 26-job Container Apps platform, its three managed identities, their role assignments and its alert rules in four Bicep files reconciled by pipeline on every push.

• Planned and ran a media migration to AWS behind an explicit approval gate, then reversed part of it when monthly spend held near $300.

• Rewrote a working embedding pipeline twice in seven months, cutting it from 19 nodes to 14 while adding controlled batching.

• Packaged an internal platform as a documented developer workspace, after which three colleagues and an external vendor built their own workflows on it.

I replace the hand-run checklist with a pipeline, and the pipeline becomes the way the team works.

• Founded and ran a 32-repository GitHub organization across 21 months, carrying 412 issues and a 403-item delivery board.

• Introduced source control and automated deployment to a client's production CRM, and wrote its first system documentation.

• Diagnosed repeated deploy failures on a client site and migrated hosting, adding a CI gate that verifies the export before every deploy.

• Replaced hand-run network health checks with an Azure DevOps pipeline that became the team standard for verifying devices before and after every change.

• Rolled one discovery-protocol standard across a live multi-vendor enterprise production network with a Python pipeline that checked each device against the customer standard first.

I build reporting pipelines that reconcile to the source document, and I fix the silent failures nobody had noticed yet.

• Rebuilt twelve years of quarterly regulatory cost-report databases to parse 13 new settlement columns, inside a 44-hour budget.

• Shipped a settlement reporting feature that passed acceptance testing on the first validated pass, tied to the source document to the dollar.

• Diagnosed and permanently fixed two silent data-quality failures in quarterly reimbursement pipelines, adding preventive validation.

• Sole engineer on a fixed-scope reporting build, closing at 99.75 hours against a 100-hour budget with all time billed.

• Cut roughly a fifth of the rows out of a reporting dataset by collapsing exact-duplicate cost-report versions, verified A/B.

React and Azure, end to end, on one template I built so the seventh application costs a fraction of the first.

• Shipped six internal React applications and one external platform on a single Azure Static Web Apps and Functions template in six months.

• Took over a decade-old production CRM from its departing in-house engineer and became its only developer.

• Sole developer on a React and Azure intake and tracking application for a multi-site infrastructure migration, shipped in eight weeks.

• Built and shipped a marketing website solo in about one week on Next.js 16, statically exported and live in production.

• Diagnosed and fixed a silent data-correctness bug where a paginated CMS fetch let boundary entries duplicate or vanish from the built site.

I build the monitoring estate from nothing and then diagnose it from first principles when it is the thing that breaks.

• Built a Zabbix monitoring estate from nothing that now watches 59 hosts across three networks through four encrypted proxies.

• Automated manual per-tenant checking into a 26-job platform across 55 tenants that reports into Teams for action.

• Diagnosed a monitoring platform performance failure past the obvious database cause to log-key items saturating the host.

• Caught a scheduled sync that had failed fourteen consecutive days, been auto-suspended by the platform, then re-activated without diagnosis.

• Built a virtual-desktop quota monitor that warns users, posts to Teams and opens tickets at three thresholds, kept in production for twenty months.

I work Power Platform the way I work code: reviewed, risk-registered, and checked for the delete nobody guarded.

• Found and escalated a data-destruction risk in an inherited production system during a self-initiated survey, driving it to a client decision.

• Audited an inherited Power Platform production system and produced a nine-page architecture review with a five-item risk register.

• Sole engineer on a Power Platform and IoT remote-management build: 149.5 hours across 21 tickets, all invoiced.

• Shipped changes as last modifier and publisher into a 21-screen, 598-control field survey application in daily production use.

• Created or modified 53 Power Platform artifacts across 13 environments in a tenant, 37 of them built from scratch.

I build the Windows application that runs the front desk, and it stays in production.

• Delivered a Windows records and billing system that went into production and has held live client records and billing history since.

• Built and shipped an internal Electron and React desktop time-tracking app on Windows and macOS with Entra SSO and auto-update.

I take a vision problem from first artefact to a working model on a fixed price and a fixed date.

• Delivered a fixed-price terrain surface-type and K-factor detection build end to end in 21 days.

• Fine-tuned an eight-class aerial terrain detector from COCO-pretrained weights, reaching mAP at 0.5 of 0.88 on its validation set.

• Trained and iterated a thirteen-class YOLOv8n breed detector across three model versions, exported to run on Raspberry Pi CPU.

I ship to hardware fleets in the field, where a bad release is a truck roll rather than a rollback.

• Designed a dual-channel release pipeline for a Raspberry Pi kiosk fleet, letting one device soak a pre-release build while the rest stay on released.

• Delivered a dual-camera embedded video reference build on Raspberry Pi 5, measured at roughly 57 percent CPU free under full load.

Licensed Electronics Engineer. I design and build the board as readily as the software that talks to it.

• Scoped, built and handed over 35 fixed-price builds across seven disciplines between 2017 and 2020.

• Built a non-intrusive load monitoring instrument that identifies household appliances from mains current alone, end to end.

• Replaced a board's 10-bit internal converter with a differential 16-bit external one to resolve appliance signatures spanning 0.3 A to 6.5 A on a 230 V supply.

• Cut an on-device classifier from about 209 MB to about 26 MB so inference ran fully offline on the hardware.

I harden a Linux fleet in Bash and leave behind one repeatable sweep instead of a per-host ritual.

• Automated a Linux security risk assessment in Bash, replacing per-host manual review of hardening, PAM, syslog and iptables with one repeatable sweep.

I build structured, machine-readable knowledge bases with refresh pipelines and redaction gates, so what a system knows survives the engineer who knew it.

• Reconstructed three undocumented inherited systems into read-only knowledge vaults in eight days, 359 notes with refresh pipelines and redaction gates.

Two years of enterprise routing, switching and SD-WAN site migration, and fifteen months of telecom core before it. The Cisco certificates behind it were earned in 2023.

• Earned CCNP Enterprise and two Cisco specialist certificates within fifteen days while delivering enterprise SD-WAN site migrations full time.

• Migrated enterprise sites onto a new SD-WAN fabric end to end: pre-evaluation, provisioning, change plan, cutover, segmentation and cleanup.

• Built and shared a template that computed subnetting from one IP address and produced copy-ready VLAN and router configuration for the deployment team.

• Directed subcontractors building out a telecom core data center on site, setting cable routes, lengths and labelling from survey through to provisioned hardware.

I replace repeated manual work on network devices with Python that runs in a pipeline, including where the vendor exposed no API at all.

• Built a change-impact simulator for an enterprise IS-IS core that returned the traffic path, the affected devices and backup-route state without logging into every router.

• Automated monitoring checks, alert triage and agent credential rotation on two network platforms with Selenium, where neither vendor exposed an API.

• Selected by management from the team for vendor network automation training, then mentored colleagues into the practice afterwards.

I have taken a consumer app through both store review processes and out the other side.

• Shipped a consumer content app to the Apple App Store and Google Play as its largest committer, and its only active developer for four months.