Quote Monday, Invoice Friday: My 5-Day Claude Code Client

By Lazar Milicevic · Published June 19, 2026 · 9 min read

Most Claude Code freelancers I talk to have the same problem. They can build. They've shipped side projects. But when a real small business owner asks "how much and how long," they freeze, over-scope, quote two months out, and get ghosted. The work itself takes maybe twelve focused hours with Claude Code. The gap isn't skill — it's delivery cadence. Here's the exact one I run, Monday to Friday, $800–$2,400 per engagement, three deliverables per client.

The economics: why a 5-day sprint actually works

Before the day-by-day, the math matters. If you quote a six-week project, you're competing against agencies, your client is comparing you to a hire, and your cash flow dies between deposit and final invoice. A 5-day sprint flips every one of those.

Here's the structure I run on every engagement:

One sprint per week. That's roughly $4k–$10k/month from one builder, no employees, no recurring support hell. The 50% deposit on Monday is non-negotiable — if it doesn't hit in 48 hours, the slot goes to the next client. No chasing, no follow-ups, no "circling back."

The three rules that hold this together:

• Fixed price, never hourly
• Three deliverables, never four
• Non-goals are written before code

Day 1 — Monday: turn a conversation into a signed quote before bedtime

Monday has exactly one job. Quote out by end of day.

I run a 30-minute discovery call. Recorded with permission. I don't take notes. I ask three questions on repeat:

1. What's the repetitive task?
2. What does it cost you in hours per week?
3. What does "done" look like?

The moment the call ends, the transcript goes into a folder called client-intake/ and I run Claude Code against it with a scope-extraction prompt:

You are a senior automation consultant. Read this discovery
call transcript and produce a one-page scope document with:

1. GOALS — what we're building, in business terms
2. NON-GOALS — what we are explicitly NOT building this week
3. THREE DELIVERABLES — concrete, demoable, named
4. ASSUMPTIONS — about stack, access, data
5. FIXED PRICE — between $800 and $2,400 based on integration
   count and data volume
6. TIMELINE — Monday quote, Friday delivery

Be ruthlessly specific. If the client mentioned five workflows,
pick the ONE worth automating this week. The other four go
in NON-GOALS.

Claude writes the first draft in about 90 seconds. I edit for ten minutes. 80% of that edit is tightening the non-goals section, because non-goals are what protect you on Thursday when the client says "hey can we also…"

Export to PDF, send with a Stripe payment link for the 50% deposit. Done by 4pm. The reason non-goals matter more than goals: every Claude Code sprint that blows up does so because of scope creep, not technical complexity. Goals are aspirational. Non-goals are contractual.

Day 2 — Tuesday: CLAUDE.md before main.py

Deposit hit. Now we build the skeleton.

The first file I create in the repo is not main.py. It's CLAUDE.md. This is the file Claude Code reads at the start of every session, and getting it right is the difference between Claude being a sniper and Claude being a chainsaw.

# Project: Acme Co. Lead Triage Automation

## Stack (in plain English)
- Client uses Gmail (Google Workspace, not personal)
- CRM is HubSpot Starter, API access enabled
- Billing is Stripe, read-only key provisioned
- Deploy target: Railway, Python 3.11

## Deliverables (from signed scope, do not change)
1. Inbound lead form → enrich → score → Slack message to sales
2. Daily 8am digest email of yesterday's leads to founder
3. Manual override endpoint to re-run enrichment on any lead

## Do NOT touch
- Don't refactor unrelated code
- Don't add new dependencies without asking
- Don't change the database schema after Wednesday
- Don't touch the Stripe integration — read-only, period
- Don't introduce async unless I explicitly request it

With that in place I scaffold the project, wire up the integrations the client mentioned, and push a deploy to a staging URL. Empty shell. They can log in. Nothing does anything useful yet. But it's real, on a real domain.

That single link is what kills buyer's remorse. They paid Monday. By Tuesday evening they see their company name on a real working URL. Refund anxiety is gone.

What goes in CLAUDE.md vs what doesn't

• Goes in: stack reality, hard constraints, deliverables, do-not-touch list, naming conventions
• Stays out: code style preferences (use a linter), task lists (use TODO comments), historical decisions (use git)

Day 3 — Wednesday: one Claude session, one core automation

This is build day. The entire day is one Claude Code session focused on the single main deliverable.

Pick one. Email triage that sorts inbox into reply-now / reply-later / ignore. Or invoice flow that reads incoming PDFs and pushes structured data into their accounting tool. Or lead handoff that takes a form submission, enriches it, drops a briefed Slack message to sales. Doesn't matter which — what matters is that Wednesday is one thing.

I work in 20-minute loops. Prompt, review, run against real client data they emailed me Monday. Real data is critical — if you're testing against fake data, Thursday will eat you alive.

A typical loop looks like:

# Loop 1: get the skeleton compiling
$ claude "implement the lead enrichment pipeline. Pull from
  HubSpot, enrich via Clearbit, score 0-100, post to Slack
  #sales-inbound. Use the data shape in fixtures/sample_leads.json"

# Loop 2: test with real data
$ python -m app.pipelines.enrich --input fixtures/client_leads_oct.json

# Loop 3: fix the three things that broke
$ claude "Clearbit returns null for 40% of these emails.
  Add fallback to Hunter.io and log which provider hit."

By 5pm I record a 5-minute Loom showing the automation running end-to-end on their actual examples. The message I send with it is one line:

This is deliverable 1 of 3. Deliverables 2 and 3 land tomorrow. Any feedback by 10am Thursday.

Notice I'm not asking "is this good?" I'm telling them when the window closes. This single sentence saves more sprints than any technical decision I've ever made.

Day 4 — Thursday: hardening, the day amateurs skip

This is the day that decides whether the client pays the second invoice or churns in week two.

The morning is hardening:

• Error handling around every external API call (retry with backoff, circuit-break after 5 failures)
• Structured logging — every external call gets a log line with request ID, latency, status
• A small admin endpoint where the client can see runs, failures, and manually retry

# Every external call wrapped like this. Boring. Critical.
@retry(tries=3, backoff=2, exceptions=(RequestException,))
def enrich_lead(email: str) -> EnrichmentResult:
    started = time.time()
    try:
        resp = clearbit.enrich(email, timeout=8)
        log.info("enrich.ok", email=email, provider="clearbit",
                 ms=int((time.time()-started)*1000))
        return EnrichmentResult.from_clearbit(resp)
    except RequestException as e:
        log.warning("enrich.fail", email=email, error=str(e),
                    ms=int((time.time()-started)*1000))
        raise

Afternoon is deliverables 2 and 3 — almost always smaller. A weekly summary email. A one-click manual override. A simple CSV export.

Then I run Claude one more time with a prompt that earns its keep every single sprint:

Read this entire codebase and generate HANDOFF.md covering:
1. How it works (one paragraph per major flow)
2. How to restart it if it dies
3. How to read the logs and find a failed run
4. The three most likely things that will break in the first
   30 days, and what to do about each
5. Environment variables and where they live

That handoff doc cuts my support load roughly in half. Clients who would otherwise email me three times a week instead check the doc, restart the service themselves, and move on.

Day 5 — Friday: deliver, invoice, close

30-minute call. Screen share. Walk through the three deliverables. Promote staging to production live, in front of them. Hand over the HANDOFF.md. Show them the admin panel.

Then — while still on the call — I send the final invoice for the remaining 50%. Stripe link, due net-3. Paying while we're still on screen-share is dramatically more common than chasing it the following week.

Before the call ends, I plant the next sprint:

Based on what I saw in the discovery call, the natural next sprint is [X]. If you want, I can hold next Monday's slot for you. No pressure — just letting you know the slot exists.

About 40% of clients book a second sprint inside two weeks. That's the real economics of this model — sprint one wins the trust, sprints two through five are where the relationship pays.

Why bizflowai.io helps with this

The 5-day cadence above is what we run on every engagement at bizflowai.io. The repeatable pieces — the scope-doc prompt template, the CLAUDE.md boilerplate per integration stack (Gmail, HubSpot, Stripe, QuickBooks, Notion), the hardening checklist, the handoff-doc generator — those are already productized. When a client signs on Monday, the staging URL and the project scaffold exist before the deposit clears, because the playbook isn't being reinvented each week. That's the only reason quoting Monday and invoicing Friday actually closes without burning the weekend.

Frequently asked questions

What is the 5-day Claude Code freelance delivery cycle?

It's a Monday-to-Friday cadence for shipping SMB automation projects: quote on Monday, build skeleton Tuesday, core automation Wednesday, hardening Thursday, invoice Friday. Each engagement includes three deliverables priced between $800 and $2,400 based on scope. The structure solves the freelancer pricing freeze by replacing open-ended timelines with a fixed five-day window, used on every engagement at bizflowai.io.

How do I turn a discovery call into a signed quote in one day?

Run a 30-minute recorded call asking three questions on repeat: what's the repetitive task, what does it cost in hours per week, and what does done look like. Drop the transcript into Claude Code with a prompt to extract one workflow and write a one-page scope with goals, non-goals, three deliverables, assumptions, and a fixed price. Edit for 10 minutes, export to PDF, and send with a Stripe 50% deposit link.

Why does CLAUDE.md matter for client projects?

CLAUDE.md is the file Claude Code reads every session to understand the project. It should contain the client's actual stack in plain English, the three deliverables copy-pasted from the scope doc, and a list of what not to touch (no refactoring unrelated code, no new dependencies, no schema changes). This file is the difference between Claude Code acting like a sniper versus a chainsaw on your codebase.

How should I handle deposits and client deadlines?

Send the scope PDF with a Stripe payment link for a 50% deposit on Monday. If the deposit doesn't land within 48 hours, give the slot to the next client with no chasing. For feedback, don't ask 'is this good' — instead state when the window closes, for example sending a Loom Wednesday with 'any feedback by 10am Thursday.' This protects your five-day timeline.

When should I build the staging shell versus the core automation?

Build the empty staging shell on Day 2 (Tuesday), right after the deposit hits. Scaffold the repo, wire up integrations like Gmail, CRM, or billing tools, and deploy to a staging URL so the client gets a working but empty link. Save the core automation — email triage, invoice flow, or lead handoff — for Day 3 (Wednesday) as one focused build day on a single deliverable.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.