الدرس 5 · الوحدة 6: From Build to Business: AI Agency and Micro-SaaS
Subscriptions and payments: charging customers every month
الفيديو قريبًا
Learn it with your tutor on the live board
أهم نقاط الفيديو
The month-end chase
- You built a booking agent for three clients
- Every month you send invoices by hand
- One client pays late, one forgets entirely
- Your income depends on your memory
What you will learn
- What recurring revenue is and how to measure it
- How to set up subscriptions with a no-code billing tool
- How to connect payments to your agents automatically
Monthly recurring revenue
- MRR: what your subscriptions bring in each month
- Only repeating charges count
- One-time setup fees stay out
cells:
A1: Client
B1: Plan
C1: Monthly fee
D1: Setup fee
A2: Bright Smile Dental
B2: Growth
C2: 299
D2: 500
A3: Glow Salon
B3: Starter
C3: 149
D3: 300
A4: Peak Fitness
B4: Starter
C4: 149
D4: 300
A5: MRR
format: {C: currency:0, D: currency:0}
steps:
- at: "three clients on monthly plans"
select: C2:C4
- at: "five hundred and ninety-seven"
type: {C5: "=SUM(C2:C4)"}
highlight: C5
- at: "setup fees sit outside"
select: D2:D4 Turning your pricing into plans
- Setup fee: a one-time charge at signup
- Retainer: a fixed monthly subscription
- Usage: a metered charge for extra volume
- Billing tools support all three together
A billing tool does the hard parts
- Stripe Billing: plans, invoices, retries, receipts
- Payment Links and Checkout: no code needed
- Customer portal: clients update cards themselves
- Paddle or Lemon Squeezy: seller of record, handle sales tax
The life of a subscription
- Every subscription moves through a few states
- Paid invoices keep it active
- Failed payments trigger retries and reminders
- Too many failures end in cancellation
Connecting payments to your agents
- Stripe sends a webhook on every event
- n8n or Make receives it and decides
- Update the client sheet, email, switch the agent
layout: wide
direction: LR
components:
client: {kind: user, label: Glow Salon}
checkout: {kind: client, label: Payment link}
stripe: {kind: external, label: Stripe}
flow: {kind: worker, label: n8n workflow}
sheet: {kind: database, label: Client sheet}
mail: {kind: email, label: Welcome email}
agent: {kind: llm, label: Booking agent}
links: [client->checkout, checkout->stripe, stripe->flow, flow->sheet, flow->mail, flow->agent]
steps:
- at: "the salon owner clicks"
show: [client, checkout, stripe]
- at: "an automatic message"
show: all
- at: "follow one payment"
flow: ["client>checkout: pays", "checkout>stripe", "stripe>flow: webhook", "flow>sheet: active", "flow>mail: welcome", "flow>agent: switch on"] Worked example: usage charges
plans = {"Starter": (149, 500), "Growth": (299, 2000)}
rate = 0.04 # dollars per extra message
usage = {"Glow Salon": ("Starter", 820),
"Bright Smile": ("Growth", 1500)}
for client, (plan, used) in usage.items():
fee, included = plans[plan]
extra = max(0, used - included)
total = fee + extra * rate
print(f"{client}: {extra} extra -> ${total:.2f}") Handling failed payments kindly
- Let the tool retry over about two weeks
- Send friendly reminders with a card update link
- Pause the agent only after the final failure
- Log every change in the client sheet
Common mistake: access without a check
- Agent keeps running after a client cancels
- Model and messaging costs land on you
- Fix: agent checks subscription status first
- Status comes from webhooks, not from memory
Recap
- MRR tracks repeating income; setup fees stay out
- A billing tool handles plans, invoices, retries and tax
- Webhooks connect payments to your agents and records
Your exercise
- Create a test product with a monthly price in Stripe test mode
- Make a payment link and pay it with a test card
- Catch the webhook in n8n or Make
- Write the client as active in a Google Sheet
النص المكتوب
The month-end chase. Picture this. You've built an AI agent that books appointments for a dental clinic, a hair salon and a gym. The agents work beautifully. But at the end of every month you open your laptop, write three invoices by hand, email them, and then wait. The salon pays late. The gym forgets completely, and you feel awkward reminding them. Meanwhile their agents keep running, and your model costs keep coming in. Look at that pile of invoices on the desk. This lesson is about replacing that whole routine with subscriptions that charge, remind and update access on their own.
What you will learn. Here's the plan for today. First, you'll learn what recurring revenue means and how to measure it with one simple number. Second, you'll see how to set up monthly subscriptions in a billing tool without writing payment code yourself. Third, and this is the part most agency builders skip, you'll connect those payments to your automations, so a client who pays gets their agent switched on, and a client who stops paying gets a polite reminder before anything is turned off. Think of the calendar with a coin on the first of every month, and a robot that watches it for you.
Monthly recurring revenue. The number every subscription business watches is MRR, short for monthly recurring revenue. It's simply the money your subscriptions bring in every month, like a salary you pay yourself from many small employers. Here are three clients on monthly plans. To get MRR, add up the monthly fees, and you get five hundred and ninety-seven dollars. Notice the setup fees sit outside that total. They're real income, but they happen once, so they don't tell you what next month looks like. MRR does. If it grows each month, your business is growing, even before you count new setup work.
Turning your pricing into plans. In the last lesson you priced your work with setup fees, retainers and usage. Now each one becomes something a billing tool understands. The setup fee is a one-time charge on the first invoice. The retainer becomes a subscription price, say one hundred and forty-nine dollars a month. Usage becomes a metered price, which means the tool counts something, like customer messages your agent answered, and charges per unit above an included amount. Usage is billed after the month it was used, so it shows up on the next month's bill. The nice part is that they all appear on the same monthly invoice, so your client sees one clear bill instead of three confusing ones.
A billing tool does the hard parts. You don't build payments yourself. A billing tool like Stripe Billing stores the card, creates the invoice on the right day, retries failed charges and emails receipts. You create a product, add a monthly price, and Stripe gives you a payment link you can drop on your landing page or paste into an email, or a hosted Checkout page it builds for you. Clients also get a customer portal where they change their card or cancel without messaging you. Selling to clients in many countries? Then look at Paddle or Lemon Squeezy, which act as the seller on paper and handle sales tax for you, for a slightly higher fee.
The life of a subscription. Every subscription follows the same life. It starts at checkout, where the client enters a card. Then it becomes active. Each month an invoice is created, and when it's paid, the subscription stays active. Sometimes a card expires or has no funds, so the payment fails. The tool doesn't give up straight away. It retries over several days and emails the client a reminder, a process called dunning, which is just a polite word for chasing a late payment. If the client updates the card and a retry works, the subscription is active again. Only after several failed retries does the subscription become canceled. Your automations should react to each of these states.
Connecting payments to your agents. Here's where billing becomes automation. Say the salon owner clicks your payment link and pays. Stripe records it and then sends a webhook, which is an automatic message to an address you choose, like a doorbell that rings in your workflow. Your n8n or Make workflow listens for that doorbell. Let's follow one payment. The client pays, Stripe rings the webhook, and the workflow marks the salon as active in your client sheet, sends a welcome email, and switches on their booking agent. Nobody touched a keyboard, and the client was live within seconds.
Worked example: usage charges. Let's check a usage bill so you understand what the billing tool computes for you. Starter costs one hundred and forty-nine dollars and includes five hundred answered messages. Growth costs two hundred and ninety-nine and includes two thousand. Every extra message costs four cents. Glow Salon is on Starter and its agent answered eight hundred and twenty messages, so that's three hundred and twenty extra, which adds twelve dollars and eighty cents. So its bill is one hundred and forty-nine plus twelve dollars eighty, one hundred and sixty-one dollars and eighty cents. Bright Smile used fifteen hundred, under its limit, so it pays just the plan price, two hundred and ninety-nine dollars. In practice your workflow reports the message count to Stripe, and Stripe does this sum on the invoice.
Handling failed payments kindly. Failed payments happen to every business, usually because a card expired, not because the client wants to leave. So handle them kindly. Let Stripe's smart retries try the card over roughly two weeks. Each failure fires an event, and your workflow sends a friendly reminder with a link to the customer portal, where they update the card in one minute. Only when the final retry fails do you pause the agent, and you log every step in the client sheet. Done this way, most clients fix it themselves, and you never have that awkward phone call.
Common mistake: access without a check. Here's the mistake that quietly drains new agency owners. You set up billing, but nothing connects it to the agent. A client cancels in the portal, the notice lies unread, and their robot keeps answering messages for months. Every model call and every text message is now paid by you. The fix is simple. Keep a status column in your client sheet that only webhooks update, and make the very first step of each agent workflow check it. If the status isn't active, the workflow stops. Status should come from Stripe's events, never from what you remember.
Recap. Let's pull it together. First, MRR, your monthly recurring revenue, is the sum of repeating charges, and it's the number that shows whether your business is growing. One-time setup fees are welcome, but they stay out of it. Second, a billing tool like Stripe, Paddle or Lemon Squeezy handles plans, invoices, retries, receipts and, in some cases, tax, so you never write payment code. Third, webhooks tie it all together: payments switch agents on, failures trigger kind reminders, and cancellations pause the work. Picture the owner sipping coffee while coins drop into the jar every month. That's the difference between chasing invoices and owning a calm, steady business.
Your exercise. Now it's your turn. Open Stripe in test mode, which uses fake money so nothing is charged. Create a product called Booking Agent Starter with a monthly price of one hundred and forty-nine dollars, then create a payment link for it. Pay it yourself with Stripe's test card number, four two four two repeated four times. In n8n or Make, add a webhook trigger and register its public production address in Stripe, for example on n8n cloud or Make, because Stripe cannot reach a copy running only on your own computer. When the checkout session completed event arrives, write a new row to a Google Sheet with the client's email and the status active. Once that row appears on its own, you've built your first self-running billing loop.
استكشف الرسوم المتحركة
الرسوم المتحركة نفسها التي في الفيديو، دقيقة وتفاعلية: شغّلها أو أوقفها، أو اسحب المؤشر، أو انتقل إلى أي خطوة بالسرعة التي تناسبك.
Loading the animation...
Loading the animation...
ملخص الدرس
- مشاهدة الفيديو
- MRR tracks repeating income; setup fees stay out
- A billing tool handles plans, invoices, retries and tax
- Webhooks connect payments to your agents and records