Senior software engineer and architect · Independent consultant

I'm Cory Hyland. I build the parts of your product you can't afford to get wrong.

The backend systems that move money, run on schedule, and are expensive to get wrong: payments, complex integrations, high-volume data, and production AI. Built to be reliable and to hold up under real usage. I take systems end to end, from architecture through deployment and the maintenance after, or step into an existing codebase to push a hard piece forward.

Over the last two years that has mostly meant payments and billing built from scratch: charging, subscriptions, payouts, and reconciliation designed and run as one system rather than assembled from parts.

Get in touch View selected work

At a glance

Experience: 20+ years, software and infrastructure
Core stack: Laravel, PHP, Python, Node.js, TypeScript
Focus: Payments, integrations, data, AI
Open to: Fractional, contract, C2C, or full-time
Working style: 100% remote, no travel

About

I'm a senior software engineer with over twenty years in technology and more than fifteen writing production software. I've run my own consultancy, Coding Chicken, since 2017, building backend and full-stack systems for SaaS platforms, marketplaces, and e-commerce. I specialize in the work that's expensive to get wrong: payment and payout systems, the scheduling and integration infrastructure that keeps a platform running, and bringing AI into real products. I work independently, fully remote, and I take ownership end to end, from architecture through deployment and the maintenance after.

Not all of that is project work. Some of it is long-running product engineering on tools with a large installed base, which is where much of my experience with large, awkward datasets comes from. It's a different discipline: you live with every decision, and the ones that were wrong come back.

Software is the second half of the story. For a decade before it I ran IT and infrastructure, latterly as a director with multiple sites and two datacentres to answer for, and earlier inside a regulated bank. That's where the instincts on this page come from. Monitoring that exists before the incident, jobs sized to the resources actually available, failures that surface instead of passing quietly: those are habits from years of being the person called when something stopped, not preferences picked up later. It's also not entirely in the past. I still run managed IT for a few long-standing clients, and the virtualization, storage, and network infrastructure I use day to day is my own.

What I do

Four areas I go deepest on, the ones where a bug costs real money or real trust.

Payments and billing

Marketplace and multi-party payments, subscription billing, automated payouts, remittance, and reconciliation across refunds, disputes, and fees. Stripe Connect and PayPal. Built from scratch when an off-the-shelf checkout doesn't fit.

Integrations and reliability

Third-party APIs and webhooks, plus the reliability layer built so failures surface instead of passing silently: idempotency, retries, monitoring, and the operational care that goes into keeping connected systems dependable.

Scheduling and data at scale

Scheduling and background-job infrastructure in Python and Celery, running tens of thousands of jobs a day and designed to be idempotent so retries and duplicate runs are safe. Plus import, export, and sync built to keep data consistent across systems without manual babysitting.

AI and LLM integration

Production AI built into real products: LLM integration, structured outputs, and tool use, kept inside a scaffold that stays deterministic where it can, with the evals and regression tests that show whether it still works. It builds on machine-learning work I started around 2014, carried forward into today's LLM systems.

Selected work

A representative picture of systems I've owned. Most of this is private, confidential client work, so the details are anonymized, but the work and the responsibility are real.

Marketplace payments and automated payouts

A multi-party SaaS marketplace moving tens of millions of dollars a year.

What I built: A Stripe Connect payment system built from scratch, handling marketplace charges, automated partner payouts, remittance, and reconciliation across refunds, disputes, and fees at tens of millions a year in total volume.
The hard part: A refund or chargeback is rarely one movement. It usually means reversing the original transfer to the merchant, then debiting that merchant separately for whatever the reversal doesn't cover, so the platform keeps its full fees and the merchant covers what's owed to Stripe. Each of those is its own transaction, and they all still have to reconcile.
Outcome: Became the financial backbone of the platform, architected to extend to additional partners and clients.

High-volume scheduling and background processing

A platform running continuous automated workflows across thousands of sites.

What I built: Python and Celery scheduling and background-job infrastructure running tens of thousands of scheduled jobs a day across thousands of sites, designed to be idempotent so a missed or duplicated run is safe rather than costly.
The hard part: What should run is not fixed. Schedules are gated by each site's licence and configuration, so the runner has to work out what is still entitled to run as that changes, and handle retries and failures without doing the same work twice.
Outcome: Sustained operation at that volume without manual oversight, with failures surfaced rather than passing silently.

High-volume data import, export, and sync

Over 100,000 items resynced in full each night, with selected data kept current in near real time.

What I built: Import, export, and sync pipelines carrying full detail for more than 100,000 items on a nightly cycle, with a faster path for the fields that can't wait for the next run. Validation, alerting, and error handling throughout.
The hard part: Source data doesn't hold still. The pipelines recognise the shape changes that can be anticipated and recover from them rather than failing the run, and raise an alert for the ones that can't. The nightly window also has to close on time on the resources actually available, so throughput is part of the design rather than something to tune afterwards.
Outcome: Removed error-prone manual data work and kept disparate systems aligned, with the failures that do happen surfaced instead of passing silently.

AI-generated import configuration

Turning unfamiliar source data into a working import, on demand.

What I built: A system that reads source data it hasn't seen before, along with whatever the user can tell it about that data, and produces the configuration needed to import it. The model has room to interpret the source; what it returns is constrained to configuration the target system will accept.
The hard part: Leeway and reliability pull against each other. The interpretation has to be loose enough for shapes nobody anticipated and tight enough that the result stays usable, so the model sits inside a scaffold that keeps as much of the work deterministic as possible. It also needed regression tests and an autonomous improvement loop worth trusting, which took as much refining as the feature did. A suite that passes while the output quietly degrades is worse than no suite at all.
Outcome: One instruction set serves both the import path and an MCP server, so the two stay in step rather than drifting apart.

The stack I reach for

Deep in the PHP and Laravel world, with Python and Celery for scheduled and background work, comfortable across the front end, and at home on the infrastructure and payments side. The tools matter less than knowing where things break.

Backend

PHP Laravel Laravel Nova Python Celery Node.js REST APIs Queued & scheduled jobs

Front end

Vue Next.js React TypeScript JavaScript Tailwind CSS

Data

MySQL Redis MongoDB

Payments & billing

Stripe Stripe Connect Stripe Billing PayPal

Infra & delivery

Git CI/CD Infrastructure as code Secrets management Laravel Forge Vercel AWS DigitalOcean LLM / AI

Infrastructure & IT

Proxmox VMware ZFS / TrueNAS OPNsense Active Directory SSO & identity

WordPress and WooCommerce too, when a project calls for it.

How I work

I take ownership. I'd rather understand the whole system than patch a symptom, I build for production and the maintenance that follows, and I keep things documented so they don't fall apart when I step away. Communication is clear and consistent, mostly async and in writing, which keeps a steady record and keeps work moving.

Anything I build gets real-time monitoring and analytics from the start rather than bolted on afterwards. Knowing what a system is actually doing is what tells you where to refine it next and where the extra capacity should go. Without it you're guessing.

Whether it starts as an MVP to prove an idea or a system I own end to end, I build it to hold up in production and to last.

What I run

Client work goes out under Coding Chicken. Pinnacle Plugins is where my own WordPress plugins live.

Coding Chicken

My independent software consultancy, running since 2017. The home for client engagements, from architecture through deployment and the maintenance after.

Pinnacle Plugins

My own WordPress plugins and add-ons, by Coding Chicken. Free on WordPress.org, with paid add-ons for the advanced cases.

Let's talk

Open to fractional engineering leadership, contract and C2C engagements, or a full-time role. 100% remote, no travel. Tell me what you're building and where it's getting hard, and I'll tell you straight whether I'm a fit. The contact page is the fastest way to reach me.

LinkedIn GitHub

Get in touch