Last time: how quality stopped depending on any one person. But the client never sees quality inside production — he only sees what we show him. If weeks of silence pass between a brief and a finished result, trust runs on faith alone. And on an 18-month project with AVT, faith runs out faster than it sounds.
So the second question, right after "is it done well," is: does the client actually know what's happening with his project right now?
Plan first, work second
Before starting any body type, we lock in the sequence: brief, storyboard, animation. Once the storyboard is ready, we estimate the scope for every tutorial, every configuration, every body type. Sometimes that's a plan several months out.
The client sees this before work starts — what will be built, in what order, at what scope. "How long will this take" gets answered with a number he can check against reality later, not a promise.
Every week, without being asked
Every week, the client gets a report: what got done, what's planned for the following week, and how much scope that closes out.
The format is simple, but it has one property that matters: it doesn't depend on mood or workload. No news, everything on track — the report still goes out. The client never has to ask "how's it going?" At any moment, he knows what stage the project is at, what's next, and what it costs.
Approval in pieces, not one final document
We never sent a storyboard for approval as one block. The levels connect to each other, but they stand as independent units, so we approved them one at a time. While one level was under review, work was already moving on another.
For the client, that means responding to a small, clear piece instead of one massive document where it's easy to miss something important. For the project, it means parallel work instead of a queue.
The storyboard itself is built so the client sees standardized frames and writes the needed text right next to each one. We used to send a rough-cut video and the client would write back: "at this minute, there should be this text." Slow, and imprecise. Now he doesn't have to rewatch anything to leave a comment.
Decisions get recorded, not assumed
When something complicated came up that couldn't get resolved over chat, we'd get the client's team and the founder on a call. The decision went into a summary, then into the storyboard itself, flagged as a change.
The client never found something in finished work that he didn't already know about. Every change went through him first. As a result, most of our suggestions for showing something faster or more clearly got accepted — the client saw the reasoning behind each proposal, not just the outcome.
Cheap approval before expensive work
Before final animation, we do a blocking pass: camera movement and logic on primitives. It costs almost nothing, but it lets us agree on direction before any artist hours go into it.
A mistake in blocking takes an hour to fix. The same mistake in finished animation takes a day. Process transparency comes down to catching gaps at the cheapest stage possible.
In a long project, trust isn't built on a polished result. It's built on the absence of surprises.
But there's an uncomfortable caveat. Transparency creates the conditions for control — it isn't control itself. You can show everything, on time, and the client can still approve a storyboard without really digging into it, then raise notes once it's already in final animation. That happened to us too. Some mistakes made it through every round of approval, spread across dozens of videos, and only got caught late.
That's next: what we got wrong.