Six services. One method underneath.
Every engagement starts in the same place: I walk the operation end to end before anything gets built. Then I build the smallest system that removes the manual work, always the same way: idempotent and safe to re-run, audit-logged, and gated on a person where a wrong automated decision would be expensive. If you already have automations that are breaking, start at audit and rescue.
The catalog is the boundary. If it is not on this page, I do not sell it.
Operations automation build
You have a process held together by copy-paste, memory and good intentions: leads moved between tools by hand, follow-ups that depend on someone remembering, statuses that never sync. I map it end to end, then build the n8n or Make engine that runs it.
The builds are not demos. A duplicate trigger does not create a duplicate record, a mid-run failure resumes instead of restarting, and anything that needs judgment stops and waits for a person instead of guessing.
- What you get
- A running engine, documented, with alerting
- Runs on
- n8n or Make.com, your existing tools
- Built in
- Idempotency, audit log, human gates
- Proof
- Cold email engine, AutoRecruit
Data layer and migrations
Automation is only as reliable as the data underneath it. I design Airtable and Supabase schemas that automations can trust, write sync scripts that keep two systems agreeing, and run migrations that arrive verified rather than hoped-for.
Airtable to Supabase migration
For when you outgrow the base. The schema, the data and the automations that depend on them move together, and the result arrives verified.
Make to n8n migration
For teams that want their automations on an engine they control. The workflows move without changing what they do.
- What you get
- A schema, sync scripts, or a verified migration
- Runs on
- Airtable, Supabase, Postgres
- Built in
- Idempotent syncs, field-level ownership
- Migrations
- Airtable to Supabase, Make to n8n
Internal tools and dashboards
When operating data lives across five tools, every basic question becomes a research project. I build Next.js apps and KPI dashboards that give a team one place to operate, fed by scheduled syncs rather than manual updates, so the numbers are current and there is exactly one definition per metric.
- What you get
- An internal app or dashboard, live data
- Runs on
- Next.js, Vercel, your data layer
- Built in
- One definition per metric, no manual refresh
- Proof
- AutoClose, AutoRecruit portal
Systems integration
Your CRM, billing, outreach and data tools each work fine alone and disagree constantly together. I connect the stack with custom API integrations built to survive bad days: rate limits respected, retries with backoff, failures logged and alerted instead of swallowed.
- What you get
- Integrations that hold under real traffic
- Worked with
- HubSpot, Stripe, Slack, Instantly, Snov, Apify and more
- Built in
- Retries, rate-limit handling, failure alerts
- Proof
- Sponsor sourcing pipeline
AI in the workflow
I add language-model steps inside real workflows: classification, generation, routing, retrieval and agents. The discipline is what makes them safe to run unattended: answers grounded in your sources instead of invented, oversized inputs filtered before they cost money, anything the model is not confident about routed to a person.
- What you get
- AI steps that run unattended, safely
- Runs on
- OpenAI, Cohere, Supabase pgvector
- Built in
- Source grounding, cost ceilings, confidence gates
- Proof
- Recruitment retrieval layer
Automation audit and rescue
You already have automations. Some are breaking, some are switched off because nobody trusts them, and the person who built them is gone. I trace what a workflow actually does end to end, classify every node by rule into core, redundant, dead or unknown, and hand back a documented system with a defined path to production.
Rescue means you keep what works. The goal is a system someone other than the original author can operate, not a rebuild invoice.
- What you get
- A node-by-node map, a verdict, a repair path
- Runs on
- n8n, Make
- Method
- Every node classified: core, redundant, dead, unknown
Not sure which one you need?
That is normal: most operations problems touch two or three of these at once. Bring me the process, not the service name.
Three ways in
- Audit first
- A bounded look at the automations you already have: a node-by-node map, a verdict, a repair path
- Fixed-scope build
- A recommendation in writing, and it arrives before you commit to anything
- Hourly through Upwork
- Platform payment protection for ongoing or exploratory work