Most AI automation agencies stall between $5,000 and $15,000 a month. Not because they run out of leads. Not because clients stop paying. They stall because every single project feels like starting from scratch.
You take a discovery call, you figure out what the client needs, you build something, you hand it over, and then two weeks later you are doing the exact same discovery dance with a new client. Every build is slightly different. Every handoff is improvised. Every workflow is stored in your head instead of in a system.
That is the real ceiling. And the way you break through it is by treating your agency like a product, not a custom shop.
This post walks through a concrete, repeatable discovery-to-delivery process you can install in your agency right now. This is not theory. These are the actual stages, tools, and timing used by agencies doing $30,000 to $80,000 per month in AI automation retainers.
Why Most Agencies Skip the Process Step
When you land your first couple of clients, you do not need a process. You remember everything, you are hungry, and you will do whatever it takes. That scrappiness gets you to $5k or $10k a month.
But at some point the scrappiness becomes the problem. You forget what you promised client B because you are too deep in client A's Airtable base. You quote a 10-day turnaround and it takes 25 because the build was more complicated than you expected. You lose a client not because the automation stopped working, but because they felt like you were disorganized.
A repeatable process fixes all of that. It compresses build times, improves client communication, and makes it possible to hire and delegate without the whole thing falling apart.
The goal is simple: every client moves through the same stages, the same checkpoints, and the same handoff structure, regardless of who is doing the work.
Stage 1: Scoped Discovery (Day 1 to Day 3)
Discovery is not a casual conversation. It is a structured intake that produces a written scope document before any tool gets opened.
Start with a 45-minute discovery call. Your job on this call is not to pitch. Your job is to understand three things:
- What is the most painful manual process happening right now
- What tools are already in use (CRM, calendar, email, phone system)
- What a successful outcome looks like in measurable terms (time saved, leads converted, revenue per month)
After the call, send a Discovery Summary within 24 hours. This is a one-page document that confirms what you heard, outlines two or three possible automation approaches, and states clearly what you will need from the client to move forward. Tool stack, login access, sample data, or whatever applies.
This step does something important beyond just being organized. It signals to the client that you run a real operation. Agencies that skip this step lose deals to agencies that do not, even when the technical skills are identical.
Keep your discovery intake in a standardized form. Use Airtable or a Typeform connected to Airtable so every client's data lives in the same place. Fields should include their industry, current tools, the specific pain point, estimated monthly volume (how many leads, how many appointments, how many invoices), and their timeline.
That data becomes your proposal. It also becomes your case study later.
Stage 2: Scoping and Proposal (Day 3 to Day 5)
Once you have the discovery data, you scope the project before you propose a price. Scoping means writing out exactly what you will build, in plain English, broken into modules.
For example, if you are building a lead follow-up automation for a roofing company, your scope might look like this:
- Inbound lead capture from website form using Make, connected to Google Sheets and their CRM
- Immediate SMS and email follow-up sent within 90 seconds of form submission using Twilio and SendGrid
- Three-touch follow-up sequence over 7 days if the lead does not respond
- Lead status update in their CRM triggered by reply detection
- Weekly summary report sent to the owner via email using a Make scheduled scenario
Each module has a clear start and end. Each one is something you have built before or something you can build from a template.
Now you price it. At NURO, we recommend module-based pricing rather than hourly. A module is worth $300 to $800 depending on complexity. The example above is five modules, so the build fee sits between $1,500 and $4,000 depending on the client's tech stack and whether any custom API work is involved. Add a monthly retainer of $500 to $1,500 for maintenance, updates, and monitoring.
Send the proposal as a PDF, not a Google Doc link. It should include the scope, the investment, the timeline, and exactly what you need from the client to kick off. Use a tool like PandaDoc or DocSeal to get it signed electronically and keep a record.
Stage 3: Kickoff and Access (Day 5 to Day 7)
Once the proposal is signed, you do not start building yet. You run a kickoff call and collect everything you need before you open n8n or Make.
The kickoff call has one job: walk through the scope one more time with the client and confirm access to every tool mentioned. This is where projects fall apart if you skip it. You start building, you hit a wall because the client does not have API access enabled or their Zapier account is on the free plan, and now you are chasing them via email while your timeline slips.
Create a simple kickoff checklist in Airtable or Notion with every credential and access item you need. Share it with the client before the call. Walk through it on the call. Do not move to the build stage until everything on the list is checked.
This sounds overly rigid. It is not. Clients respect it. It tells them you are serious and that you expect them to be serious too.
Stage 4: Build Phase (Day 7 to Day 14)
This is where most agency owners spend all their time and energy because building is the fun part. The problem is that without the previous stages, the build phase becomes chaotic and bloated.
With a clean scope and confirmed access, a standard AI automation build should take five to eight business days for a three to five module project. If it is taking longer than that, one of two things is happening: the scope was not tight enough, or you are building something you do not have a template for.
This is why templates matter so much. Every build you complete should produce a reusable template. In Make, you can export a scenario as a blueprint JSON file. In n8n, you can export a workflow as a JSON file. Store these in a shared Google Drive or Notion doc organized by use case and industry.
Over time, you build a library. A new dental office client comes in, and you already have a working appointment reminder workflow you built for a chiropractic clinic three months ago. You copy the template, swap out the API keys and phone numbers, test it, and you are done in two days instead of eight.
During the build phase, send the client one update every two business days. Not a long report. Just two or three sentences confirming what was completed and what is next. This prevents the silence that makes clients anxious and generates unnecessary check-in emails.
Use a project board in Notion or Airtable with the following columns: To Build, In Progress, Testing, Client Review, Done. Share view-only access with the client so they can see status without emailing you.
Stage 5: Testing and QA (Day 14 to Day 16)
Every automation needs to be tested against real conditions before it goes to the client for review. This means running the workflow with actual data, not just dummy inputs.
For a lead follow-up automation, submit a real test lead and watch every step fire. Check that the SMS lands in under two minutes. Check that the CRM updates. Check that the follow-up sequence triggers correctly if no reply comes in. Check the edge cases: what happens if the phone number is invalid, what happens if the form is submitted twice with the same email.
Document your test results. A simple table with the scenario, expected result, and actual result is enough. When the client asks "did you test this?" you have a paper trail.
If the workflow involves AI components, like a Claude or GPT call for response generation or classification, test it with a dozen different inputs. Look for hallucinations, formatting breaks, and token overflow issues. These are the things that slip through when you only test one scenario.
Fix any issues, re-run the tests, and only then send it to the client for review.
Stage 6: Client Review and Handoff (Day 16 to Day 20)
Send the client a short Loom video walking through exactly what was built and how it works. Show the workflow visually. Narrate what each step does. This takes 10 to 15 minutes to record and it cuts client questions down dramatically.
Include a written handoff document that covers:
- What the automation does and when it triggers
- What the client needs to monitor or maintain on their end
- What happens if something breaks and how to notify you
- A link to the shared project board for reference
Give the client three to five business days to review and test on their side. Ask for one consolidated round of feedback rather than back-and-forth emails. Build one round of revisions into your scope. Anything beyond that is a change order.
When revisions are complete, the automation goes live. This is a milestone worth marking. Send a short email confirming the go-live, summarizing what is now running, and setting expectations for the first 30 days.
Stage 7: Retainer and Ongoing Management
The build fee is how you get paid once. The retainer is how you build a real business.
Every client should move to a monthly retainer after the initial build. A standard retainer for one to three automations covers monitoring, updates when connected tools change their APIs, minor adjustments, and a monthly check-in call.
Price this at $500 to $1,500 per month depending on the complexity of the stack and the number of automations running. At eight retainer clients paying $750 per month each, that is $6,000 in recurring revenue before you do any new builds. At twenty clients, that is $15,000 per month in mostly passive income.
The key to retainer clients staying is proactive communication. Do not wait for something to break. Send a short monthly report showing the automation stats: how many leads processed, how many messages sent, how many hours saved. Pull this data from Make's scenario run logs or from a connected Google Sheet that your workflow writes to.
Clients who see the numbers stay. Clients who never hear from you cancel.
Building Your Template and SOP Library
Everything described above only scales if it is documented. Every time you build something new, add it to your SOP library. Every time you solve a weird API problem, write a one-page note about how you solved it.
Your SOP library should live in Notion and include:
- Workflow blueprints organized by industry and use case
- Discovery call script and scoring rubric
- Proposal template with module pricing guide
- Kickoff checklist by tool type (GoHighLevel, HubSpot, Jobber, etc.)
- Testing checklist by automation type
- Handoff Loom script outline
- Monthly retainer report template
When you have this library, you can hire a contractor and get them productive in a week instead of three months. You can take on more clients without working more hours. You can sell your agency or bring on a partner because the knowledge lives outside your head.
The Numbers That Make This Real
Here is what this process looks like when it is running at a small scale:
- 4 new builds per month at an average of $2,500 each: $10,000 in build revenue
- 15 retainer clients at $750 per month: $11,250 in recurring revenue
- Total monthly revenue: $21,250
Two contractors handling builds at $600 per project each reduces your build costs by $2,400 and frees up your time for sales and client management.
This is not a moonshot. Agencies hit these numbers within 12 to 18 months of starting with zero clients. The ones that get there fastest are not the best builders. They are the ones who built a process and stuck to it.
Join NURO University
If you are building an AI automation agency and you want the exact templates, workflows, scripts, and systems covered in this post, NURO University is where you go next.
Inside, you will find step-by-step courses on building automations with n8n, Make, and Zapier. You will get done-for-you proposal templates, discovery call frameworks, SOP libraries, and a community of agency owners who are actively closing clients and scaling their retainer base.
This is not a course full of theory. It is a builder's resource built by people who run agencies, not people who write about running agencies.
Join NURO University today and start building the process that gets you to $20,000 per month and beyond.