Process & tooling
Fast where it counts. Solid where it matters.
I prioritise speed without dropping quality. With a modern, AI-assisted stack I get you a working PoC or MVP in about two weeks on your real data, then harden it for production. You decide what to build next from evidence, not a slide deck. Here is exactly how that works, end to end.
- AdEscape
Why a defined process
Most automation projects fail before any code is written.
Not because the engineering is hard, but because the wrong thing got built, the cost ballooned in the dark, or the finished tool quietly broke and nobody noticed. A vague "engagement" is where budgets go to die.
The four-step method below exists to remove those failure modes one at a time. You always know which stage you are at, what it costs, and what you get out of it. The value is proven cheaply before the big spend, and nothing that ships is left to rot. It is the same process behind every project in my selected work.
The method
Four steps. You always know which one you are paying for.
Audit
Before a line of code, we work out what is actually worth automating and what it is worth.
Most automation projects fail not because the build is hard, but because the wrong thing got built. The Map phase exists to make that impossible. I sit down with your process, follow the data, and find where time and money are leaking.
You get a concrete map: which steps are worth automating, the rough effort, the expected saving, and the fastest path to proving it. If automation is not the right answer, I will tell you that too, before you have spent a real budget.
What you get
- A written process map and where the cost actually sits
- A shortlist of what to automate, ranked by ROI
- A recommended first slice to prove the value (the Prove phase)
- A rough effort and cost estimate for the full build
Pilot
One working piece, on your real data, fast, so the value is proven before the big budget.
The pilot is the heart of the speed promise. Instead of a quarter of specification documents, you get a working proof-of-concept in about two weeks that runs on your actual data and produces a result you can hold and judge.
This is where AI-assisted development earns its keep. The mechanical parts of standing up a scraper, an automation, or an app core are nearly free, so the time goes into the genuinely hard parts: the messy edge cases, the anti-bot handling, the reconciliation logic that only your data reveals.
What you get
- A working pilot running on your real data
- Honest results: what works, what is harder than expected
- A clear go / no-go decision backed by evidence
- A refined estimate for the production build
Deployment
The full system, production-ready, documented, and handed over so you own it.
With the value proven, the Build phase hardens the pilot into something a business can rely on. Validation on every input, tests on the critical paths, monitoring that pages a human when something breaks, and documentation so the system is not a black box only I understand.
Architecture is kept deliberately boring: proven frameworks, clear boundaries between fetch, transform, and deliver, and no clever tricks that become tomorrow's liability. The goal is software that keeps working when I am not looking at it.
What you get
- The production system, deployed and running
- Tests, validation, logging, and monitoring
- Documentation and a handover walkthrough
- Source code and infrastructure you own, no lock-in
Care
Monitoring, fixes, and iteration, because the sources your automation depends on never stop changing.
Scrapers and automations are living systems. A site redesigns, an API changes a field, a process evolves, and without someone watching, things quietly break. The Run phase is a retainer that keeps everything healthy and keeps developing it as your needs grow.
This is also the most honest part of the model: it is recurring revenue precisely because it is recurring value. Nothing I ship is left to rot.
What you get
- Monitoring and alerting on your systems
- Fixes when sources, sites, or APIs change
- Ongoing iteration and new features
- A predictable monthly scope and point of contact
The engineering behind the speed
How a working version lands in weeks.
Two weeks to a working pilot is not heroics or all-nighters. It is leverage. Modern AI-assisted development collapses the cost of the parts of building that used to be slow, repetitive, and error-prone, which frees almost all the time for the parts that are genuinely hard and genuinely yours.
In practice, tools like Cursor and Claude Code handle scaffolding, boilerplate, repetitive refactors, and the first draft of well-understood code in minutes instead of hours. They are pair programmers that do the typing. The judgement, architecture, edge cases, and correctness stay with me, where they belong.
The result is a different shape of project. Instead of weeks of setup before you see anything, the foundation is up in days and the real time goes into the messy reality of your data: the login that fights back, the format nobody documents, the reconciliation rule that only shows up at the edges. That is where projects actually live or die, and that is where the saved time is spent.
Crucially, this is not an "AI company". AI is a way to build faster, not the product. Every line that ships is read, understood, and owned by a human.
The stack
A modern toolchain, picked for the problem.
No single tool is the answer. The skill is matching each part of the job to the right one: AI-assisted editors for build speed, no-code platforms for orchestration, and real code for the hard parts. Code where it matters, no-code where it pays off, across every service.
Cursor
AI pair-coding
Claude Code
agentic coding
Figma
UI + prototyping
n8n
workflow automation
Make
no-code integrations
Python
scraping + APIs
Next.js
web apps
FastAPI
fast backends
The quality bar
Fast and fragile are not the same thing.
The reason most "move fast" stories end in a rewrite is that speed was bought by skipping the things that make software hold up. You do not have to make that trade. These guardrails are cheap when they go in from the start, and they are what keep the speed safe.
Strict typing
TypeScript in strict mode and typed Python. Whole classes of bugs are caught before the code runs, which is what lets me move fast without breaking things.
Tests on the critical paths
Not 100% coverage theatre, but real tests on the parts that would actually cost you money if they broke. They are also what makes fast iteration safe.
Validation at the boundaries
Every input from the outside world (scraped data, form submissions, API responses) is validated before it is trusted. Bad data is rejected, not silently stored.
Monitoring and alerting
Runs that fail, return too little data, or spike in errors page a human within a day, not a quarter. You find out from me, not from a customer.
Human review of every line
AI tooling drafts code; I read, understand, and own all of it. The codebase stays coherent and maintainable, never a pile of generated snippets nobody understands.
Boring, proven architecture
Clear boundaries, well-trodden frameworks, no cleverness for its own sake. The best automation is the one nobody has to think about.
No lock-in
What you own at the end.
When a project finishes, you own all of it: the source code, the infrastructure configuration, and the documentation. There is no proprietary platform you are forced to keep paying for and no black box that only I understand.
That is deliberate. If you ever want to take the system in-house, hand it to another developer, or simply understand exactly what it does, you can. The handover includes a walkthrough and documentation written for a human, not a note to myself. Good work should not depend on keeping the client in the dark.
FAQ
How the work gets done.
- How fast can you deliver a working version?
- Usually a working proof-of-concept in about two weeks, on your real data. You see value early and decide what to invest in next from evidence, not promises. Larger production systems take longer, but you are never waiting in the dark: the pilot proves the direction first.
- How do you keep quality high while moving fast?
- Speed comes from leverage, not corner-cutting. Strict typing, tests on the critical paths, validation at every boundary, human review of every line including AI-generated code, and monitoring keep a fast build from becoming fragile. Going fast and going carefully are not opposites when the guardrails are in from day one.
- Which tools do you use, and why?
- Cursor and Claude Code for AI-assisted development, Figma for UI and prototyping, n8n / Make / Zapier for no-code automation, and Python, FastAPI, Next.js, and Django for scrapers, backends, and apps. Each is chosen for the problem, never the other way around. The point is leverage: removing the slow, mechanical work so attention goes to the hard parts.
- Does AI write the code? Is this an 'AI company'?
- No. AI tooling writes a draft and removes the slow, mechanical parts of building. Every line that ships is read, understood, and owned by a human. AI is a way to build faster, not the product I sell. The deliverable is reliable software, not a model.
- What do I actually own at the end?
- Everything. The source code, the infrastructure config, and the documentation. No proprietary black box, no lock-in. If you ever want to take it in-house or hand it to another developer, you can.
- How does pricing work?
- The Map phase is a fixed price. The pilot and build are quoted per project once the scope is clear, priced for the outcome and the saving rather than hours. Ongoing care is a monthly retainer scoped to your needs.
- What happens after launch?
- The Run phase. Monitoring, fixes when sources or APIs change, and ongoing development on a retainer, so nothing that ships quietly rots. This is optional, but for anything that depends on external sources (scrapers especially) it is strongly recommended.
- Can you work with my existing systems and team?
- Yes. Most projects need to integrate with tools you already use and fit alongside an existing team. Clear boundaries and documentation are part of the design from day one, so the work slots in rather than becoming an island.
Want a working version in weeks?
Start with a short audit. We map the fastest path to value.