2B2BEnterprise
LIVE·build #128·--:--:--
← All posts
November 12, 2026

Mockup Approval: Why I Ask Clients to Approve a Picture, Not a Spec

A client's new reporting pages went from an approved mockup to live in about 90 minutes. The secret wasn't speed. It was what we asked him to approve.

small businesssoftware projectsclient approvalsAI teamfield notes
Mockup Approval: Why I Ask Clients to Approve a Picture, Not a Spec

Yesterday a client's new reporting pages went live about 90 minutes after the build started. The client runs an insurance-audit service for contractors. Nothing about the build was rushed. What made it fast was mockup approval: we asked for a yes on a picture, not on a document.

Here is what happened, and what any business owner can borrow from it.

What we were building

The client needed one screen that answers a simple question. For each subcontractor, how much was paid, how much of that was labor, and what paperwork is still missing?

Before writing any code, we drew it. We made a clickable mockup with the real tiles, the real columns and sample numbers. He looked at it, asked for changes, and saw a second version.

Then he said the line that started the build: "The mockup is good enough, turn it to the desk."

Why approve a mockup instead of a spec document?

A spec document is a long description of what software should do. Most owners skim it, sign it, and then say "that's not what I meant" when they see the real thing.

A mockup removes the guessing:

  • You react to what you see. Nobody has to imagine a screen from a paragraph.
  • Changes are cheap. Moving a tile on a drawing costs minutes. Moving it after it is built costs a day.
  • The yes means something. When an owner approves a picture, he has actually checked it.

For us, the approved mockup was the plan. My AI team wrote the detailed build plan from the picture, not the other way round.

How the picture became a checklist

This is the part that saved the most time. The team wrote a worked example into the plan using the mockup's own sample numbers. It had to reproduce every tile on the drawing exactly.

That turned a picture into a test anyone can run. If the finished screen shows the same numbers as the approved drawing, it is right. If it doesn't, something is wrong before the client ever sees it.

The rest followed a simple order:

Build on a practice copy

Everything was built and tested on a copy of the system, not the live one. The real data and the live site stayed untouched.

Show it, then ask for one yes

The client clicked through it on the practice copy. Then he gave one approval to put it live.

Check it on real data

Once it was live, we opened the new pages and confirmed they loaded against his real records.

Where a picture falls short

A mockup shows the happy path. It does not show the awkward cases.

In this build, the hard questions were about edge cases the drawing never showed. What counts as a one-person subcontractor? What if a payment's labor is entered as more than the payment itself? A picture can't answer those.

So the team made a call on each one and flagged it for the client instead of hiding it. That is the honest rule: the mockup settles what the screen looks like, and a short written list settles what happens when the data is messy.

How to use mockup approval in your own business

You don't need an AI team to do this. You need the habit.

  • Before any build, ask for a drawing. A website, a form, a dashboard, even a report layout.
  • Put real-looking numbers in it. Fake numbers that add up make the drawing checkable later.
  • Approve the picture, then list the exceptions. Keep the exceptions short and in plain words.
  • Check the finished thing against the picture. Same numbers, same layout, or it isn't done.

The takeaway: the fastest builds I run aren't the ones where we work harder, they're the ones where the client approved exactly what he was going to get. If you have a project stuck in "that's not what I meant," start by asking for the picture.