Story from everyday life inside a print agency
When design approval happens by email, one mixed-up version or one unclear “yes” can lead to costly print mistakes, delays, and client disputes. This story shows how it happens and why a more structured process protects both your margins and your client relationships.
On Wednesday evening, a little after six, Martin glances at his phone and sees an email from the client.
“Yep, looks good. Approved.”
That is exactly what he has been waiting for all day. The order is urgent. The run is large. The deadline is tight. The client is in a hurry, and back at the agency several people are waiting for this sign-off so they can move the job forward.
Martin works at a print agency. He is the person who keeps the client communication moving, gathers feedback, talks to the designer, passes work into production, and tries to keep everything on schedule. This week is more stressful than usual. The client is preparing a major promotion and has ordered 10,000 branded cups. There is a deadline, and missing it is not really an option.
Earlier that day, the designer made the final changes to the artwork. The logo was moved slightly, one line of text was updated, and one important change was made to the logo color so it matched what the client had asked for.
The new file was sent to the client. Or at least Martin thinks it was.
The next morning, production starts.
A day later, it becomes clear that the client approved an older version.
And from there, the familiar mess begins. Who sent what. Who saw what. Who understood what. Which file was the latest one. The client says one thing. The agency says another. There is an approval in the email thread, but there is no real clarity. And the cups have already been printed.
This is not some dramatic made-up story. It is exactly the kind of thing that can happen in any team that sends artwork for approval by email and assumes everything will somehow stay clear on its own.
And that is the real problem. Email is fine for conversation. It is not a reliable system for design approval.
The most important point
When approvals happen inside long email threads, the risk is not just that someone makes a mistake. The real risk is that nobody can say with full confidence which version was final, what changed, and what exactly was approved.
Why So Many Teams Still Rely on Email
Because it is easy. Because everyone already uses it. Because there is nothing new to learn. Because at first it seems to work.
You send a version. The client sends comments back. You make revisions. You send the file again. In the end, a “yes” comes in, and everyone assumes the process is clear.
That is true only while the number of jobs is small, the number of people involved is small, the number of versions is small, and nobody is under too much pressure.
Once the workload grows, the cracks start to show. One email contains an old file. Another contains a new one. A separate message has a note that not everyone saw. Someone opens the wrong attachment. Someone forwards the previous version. Someone replies “Looks good” from their phone without zooming in. Little by little, the team reaches the point where nobody is completely sure what was actually approved.
And in print, that is not a small issue. It is the difference between a successful job and an expensive mistake.
How It Starts: A Few Small Mix-Ups That Turn Into a Big Problem
Martin’s story does not begin with one huge error.
It begins with a few small things that seem harmless on their own.
On Monday morning, the client sends the first round of comments. Move the logo slightly to the left. Replace one line of copy. Adjust the background color so it matches another branded item more closely.
Martin forwards everything to the designer.
Later that day, the designer sends back an updated version. Martin checks it quickly, writes to the client, and sends it over. Up to this point, everything feels normal.
But the email conversation is no longer simple. There are earlier messages. There is an older attachment. There is another version that was sent for comparison. There is also an internal email between Martin and the designer.
The client opens their inbox on Tuesday evening. They are on the move, checking email on a phone, in a hurry. They open a file that seems to be the right one. They look at it quickly. Nothing stands out immediately. They reply with a short message:
“Yep, looks good. Approved.”
The problem is that the file they opened is not the latest one.
The next morning, Martin sees the approval and sends the job into production. From his point of view, the process is done. There is approval. There is a deadline. There is a print run. The job needs to move.
By Thursday afternoon, the client receives a photo of the finished cups.
That is when the phone rings.
“That is not the latest version. The logo color was not supposed to be that.”
Where the Process Breaks Down
This is not the kind of failure where you can point to one dramatic moment and say, “That is where everything went wrong.” More often, it is a chain of small disconnects.
First, there is more than one version sitting in the email thread.
Second, there is no single place that clearly shows which version is current.
Third, the client’s approval is just words in an email. It is not tied clearly and unmistakably to one specific visual.
Fourth, people are busy and work from memory. And when the day gets hectic, memory is not very reliable.
Fifth, production only hears the outcome: “We have approval.” They do not see the full story behind it.
And that is how the most frustrating kind of problem happens. There is an approval, but no certainty about what exactly was approved.
On paper, everything looks fine. In reality, it is not.
Here, the issue is not some complex failure. The break happens around something that seems small at first glance: a change in the logo color. But those small changes are often the ones that cause the biggest losses, because they are easy to miss and, once printed, they are repeated across the entire run.
Key takeaway
The problem is not whether the client wrote “yes.” The problem is whether that “yes” is clearly tied to the exact version that is supposed to go into production.
This Is Not an Isolated Case
A lot of people in the print business will read a story like this and think, “Yes, something similar has happened to us.” And that makes perfect sense.
Here are a few other very real situations that follow the same pattern.
The client reviews the artwork on a phone and misses an important detail
Sometimes the mistake does not seem major at first. A wrong date. A missing letter. An old phone number. A logo placed a few millimeters off. The wrong brand color, which is hard to spot on a small screen.
The client opens the file, looks quickly, and replies “Looks fine.” Then, when the product is printed, the detail becomes obvious.
And the discussion starts all over again. Did they see it or not. Should someone have caught it. Why was it not clearer.
One person approves it, then another person objects later
Very often, there is more than one person on the client’s side involved in the approval. The marketing manager replies first, then the owner steps in later, then someone from sales says that was not the final version.
If it is not clearly defined who gives final approval, confusion follows. One person says, “Go ahead.” Another later says, “I never approved that.”
The final comment gets buried in a separate email
This is a classic one. Someone sends back a small but important change. It comes in a separate message. The designer sees it. Martin assumes it has already been applied. Production, however, works from an older file that was downloaded earlier. The finished item is almost correct, but not quite.
And “almost correct” can still be very expensive in this business.
The wrong file is sent, and the client honestly approves it
In this case, the client has done nothing wrong. They review what was sent and confirm it. The problem is that the agency sent the wrong file.
Later, everyone realizes the revisions had been made, but the updated file never reached the client. Again, nobody is happy, because there is technically an approval, but the printed result is still wrong.
The job gets delayed because someone is constantly chasing a response
Not every loss is loud and dramatic. Some are quiet but constant.
You send the artwork. You wait. You follow up. You wait again. You call. You hear, “We’ll review it later.” Meanwhile, the next step cannot start. Production waits. The schedule shifts. People across the team sit between tasks, not knowing when this one will move.
It does not look like one major loss. But when it happens every week, it burns a lot of time.
The Hidden Cost of “Free” Email
When a small difference becomes an expensive problem
At first glance, email feels free. You do not pay extra for it. Everyone already has it. There is no new training. No new process to set up.
That is true only until you start counting the real cost.
How much does a reprint cost?
How much do wasted materials cost?
How much does lost time cost for the designer, the client-facing project lead, the production team, and the manager who has to step in and deal with the fallout?
How much does a delayed deadline cost?
How much does it cost when a client starts to wonder whether they can really trust you?
How much does it cost when you have to offer a discount, absorb the loss, or simply lose the next job because the relationship has taken a hit?
The truth is simple. Email is cheap right up until the first serious mistake. After that, it becomes an expensive habit.
And sometimes a single mistake can cost more than years of software.
The sober calculation
One bad print run, one reprint, or one lost client often costs more than a long stretch of using a proper approval tool.
Slow Approval Means Slow Jobs and Thinner Margins
When waiting blocks everything behind it
Some teams have not had one big disaster, yet they still lose money every month. Not through waste and reprints, but through delay.
The person handling the client should be moving new work forward, but instead spends time asking whether the file has been reviewed. The designer waits for comments instead of working on the next task. Production cannot plan with confidence because it does not know whether the job will be released tomorrow, later this week, or not at all.
When there is no clear signal showing whether a version has been seen, commented on, or fully approved, the whole team starts working in a fog. Somebody is always guessing. Somebody is always checking. Somebody is always digging back through email to confirm what the latest version was.
That never appears as a separate line item on an invoice, but it still has a cost. And that cost is real.
In peak season, every lost hour feels like a week. When the schedule is already full, one delay does not just move one job. It pushes into the jobs behind it, raises stress across the team, and makes the entire day heavier for everyone.
After the Mistake Comes the Dispute
The print mistake itself is bad. But sometimes the argument that follows is worse.
Because when there is no clear record of who saw what and approved what, the conversation quickly turns personal.
The client says, “This is not what we wanted.”
The agency says, “But we have your approval in email.”
The client replies, “Yes, but not for that version.”
From there, each side starts pulling toward its own version of the truth. People go back through email threads. They reopen attachments. They check dates and times. One person remembers it one way, another remembers it differently.
Instead of everyone focusing on solving the problem, the discussion becomes about blame.
That is exactly when it becomes obvious how important a clear process really is. Not just emails. Not just assumptions. One place where you can see what the latest version is, what feedback was given, and what was actually approved.
How the Same Job Would Look With a Clear Process
Picture the exact same order. The same client. The same deadline. The same pressure.
But instead of several attachments spread across email threads, there is one review link.
The client opens that link and sees only the current version. If there is a newer version, it is clearly marked. If there are comments, they sit directly on the artwork instead of being scattered through paragraphs of email. If the client does not respond in time, a reminder goes out automatically. If they approve it, there is a clear record of what exactly they approved and when.
The risk drops sharply. Not because people suddenly become perfect, but because the process itself is better.
And that is the key difference. A good system does not rely on everyone being flawless. It makes mistakes less likely in the first place.
How to Tell Your Process Is Risky
If even some of the following sounds familiar, the risk is already real:
- multiple versions sit in the same email thread;
- files are named things like “latest,” “new,” or “final-final”;
- the client often replies with a short “looks good” or “ok,” without it being clear which version they mean;
- feedback comes from different people and across different channels;
- production only hears that there is an approval, without seeing the exact version;
- someone on the team regularly digs back through email to confirm which file is current;
- follow-ups are still done manually;
- when things get busy, people rely more on memory than on a clear process.
What Should Be Clear in Every Approval
Every approval should answer a few simple questions:
- Which exact version is being approved?
- What changed compared with the previous version?
- Which person on the client side has final sign-off authority?
- When was the approval given?
- Are there any open comments left, or is everything complete?
- Is production looking at the same version the client approved?
- Is there a clear record that can still be shown a week or a month later?
It Still Makes Sense for a Smaller Team
A lot of teams put this off because they think, “We’re not that big yet. We can manage like this for now.” But team size is not the main issue.
The more important question is how much it hurts when something goes wrong.
And in print, mistakes usually hurt a lot.
If a clearer approval process helps you avoid even one bad print run, there is a good chance it pays for itself for a long time. If it saves hours otherwise spent chasing feedback, checking email threads, and sorting out version confusion, then you gain more than time. You get back focus.
If it helps you avoid even one serious dispute with an important client, the value is not only financial. It is commercial and reputational too.
That is why the better question is not just, “How much does the software cost?” A more accurate question is, “How much will the next mix-up cost us?”
What This Story Really Shows
The biggest problems in print rarely start at the machine. More often, they start earlier. In one unclear “yes.” In an old attachment. In a missed comment. In a conversation spread across too many emails and too many people.
As long as everything goes smoothly, that way of working can feel manageable. But once the volume rises and deadlines tighten, the same process starts carrying more and more risk.
Martin’s story matters for exactly that reason. Not because it is unusual. Because it is completely plausible. Maybe even familiar.
And if your team still handles design approvals by email, there is a good chance you are already paying for that habit. Sometimes in lost hours. Sometimes in stress. Sometimes in delayed jobs. Sometimes in direct financial loss.
That is why a clearer way of approving artwork is not a luxury. It is a way to protect your margin, your deadlines, and your client relationships.
Because in the end, it is not enough for the client to say “approved.”
Everyone needs to know exactly what was approved.
When It Is Time for a More Structured Way of Working
If your team still handles approvals through email, that does not mean you are doing something wrong. It usually just means you have reached the point where the old way creates more friction than convenience.
That is where Approve Design can help. It brings versions, comments, job status, and approval into one place, so it is easier to see what is current, what changed, and what has already been signed off.
Not to make the work more complicated. The opposite. To reduce the digging through email, reduce the chasing for replies, and reduce the stress that builds once the number of jobs grows.
You do not need to prevent ten mistakes to make that worthwhile. Sometimes avoiding one expensive one is enough.
If this story feels a little too familiar, take a look at how Approve Design can help you make the approval process clearer for both your team and your clients.
