What Is a Design Proof & Why Do You Need One?

What Is a Design Proof?

A design proof is a preview of your work—think of it as a visual representation that's created for review and/or approval before the final version of your project is produced. 

Design proofs are an essential step in the design process. This step allows for feedback and review to ensure that all requirements and expectations are met. In contrast, imagine sending a large-scale project to print without checking out a test copy first. You could end up with thousands of copies with a mistake or something you hadn't anticipated. Instead, having a proof gives you the opportunity to check out a "test version" of the project before you green-light production.

Why Do You Need a Design Proof?

Design proofs have many purposes. Here are some of the reasons why a design proof is such an essential part of a solid workflow:

• Checking your work—proofing is a major part of checking your work for any mistakes. This is your opportunity to see (or even hold and use) a preview of your work. Your graphics, text, images, colors, and layout are presented as they will be in the final version. This means that if something's off, you can catch it before it goes live or into larger production.
• Sharing your work for feedback—design proofs can be a crucial part of working with clients too. This is an opportunity to get feedback at vital points in the design process, including the final sign-off before going live or into production. It might look correct to you, but what if the client catches something they don't approve of? Better to catch it before the project goes live.
• Iterations and revisions—proofing is also a strong addition to the revision process. As designers, we typically expect revisions. It's just part of the process. Presenting clients with a proof can help take any ambiguity out of the project's process and outcome.
• Quality assurance—you never know when there might be an unexpected quality issue. Maybe the client's paper choice just doesn't look as good as they'd hoped. Maybe, in an interactive project, something just doesn't flow like everyone thought it would. Proofs are an essential part of testing and making sure the quality is what it should be.

Types of Design Proofs Explained

There are several types of design proofs, each with its own benefits. Let's take a look at the different kinds of proofs that you may want to work with in your next design project.

Hard Proofs

Hard proofs are hard copies of your project—like a physical, tangible test version. Let's say you're designing packaging, a magazine, or a poster. A hard proof would be a printed version of your project that you could touch, interact with, and check for any issues, errors, or places where adjustments are necessary.

This phase of the design process can also be helpful for checking things like color management, color accuracy, and print quality. 

However, hard proofs can come in many varieties. For example, let's say you're designing a magazine. You could get a hard proof that's almost a perfect match to the finished project if you wanted to. Or you could get a lower-quality hard copy, just to get a feel for the final project—maybe even without any binding. 

Different Types of Hard Proofing

Plotter proofs are a lower-quality hard-copy proof. This can be helpful if you want to be able to page through your magazine, for example, just to get a feel for the layout, the margins, and other aspects.

Press proofs, however, are created using the same press that the final project will be printed on. So the proof created here is pretty true to the final result. Keep in mind, however, that this type of proof is likely more expensive.

It's important to note that hard proofs almost always have a cost—and that cost can be significant, so you'll want to budget it into your project. While it might be tempting to skip hard proofing, let me tell you from experience—it's far more expensive to reprint an entire project than to allot funding to proofing in your budget from the start.

Soft Proofs and Digital Proofs

A soft proof, also known as a digital proof, is a proof that is strictly provided in a digital format. Its purpose, just like a hard proof, is for review, feedback, and approval. One of the main benefits of a soft proof is how easy it is to share it electronically among your team, your clients, and other parties related to your project. Soft proofs are also typically free or low cost—there's no physical production, making them quicker and less expensive than hard-copy proofs.

Check out the example below—this is a completely digital representation of a business card design. Impressive, right? While we can't actually hold it, we can get a feel for it in a high-resolution environment. 

Here are some reasons why you should use soft proofing in your workflow:

• Digital Files Are Convenient to Share—soft proofs are digital files, like PDFs, JPEGs, PNGs, or other image formats. These files can be easily shared via email or other digital messaging. 
• It's Even Easier to Revise—this is particularly advantageous for remote collaborations and teams. Something wrong with the proof? Easily change it and send out a new soft proof for a second review.
• Ideal for Interactive Elements—if your project is web-based or interactive, soft proofs aren't just convenient: they're essential. This test version could allow your client to use a clickable prototype, for example, for feedback before things go live.
• Efficency and Cost—the cost associated with hard proofing isn't an issue here. In addition, soft proofs potentially save time because they're quicker and easier to share.
• Easy Annotations and Comments—soft proofing makes it easy to add annotations and comments directly on the proof about specific changes.

Hard Proofs vs. Soft Proofs

So which is better, and what's the difference when it comes to hard proofs vs. soft proofs? The nature of them is largely where they differ, but they're both very useful.

• Hard proofs are a hard-copy example of your work.
• Soft proofs are a digital example of your work.
• Both are tools for gauging the output of your work.

There really isn't a "winner" here because they both serve a similar purpose, but in a different way. In most projects, I tend to use both. Here's a simple overview of the two, for reference: