As creatives, we're trained to work within certain restrictions to satisfy budgets. A familiar restriction is cycling through the design process while keeping within a set amount of revisions: the creative changes we perform based on client feedback. We sometimes call these 'rounds'. I find it funny that we use boxing terminology to express this type of interaction with our clients.
“Boxing, a contact sport, is supervised by a referee over a series of short intervals called 'rounds'.” (source: wikipedia.)
Such a loaded sentence.
I've been noticing other designers and agencies rethinking the way the client fits into the design process. This has encouraged me to let my “design guard” down and try something similar.
An iterative method looks at shortening the feedback loop by using smaller, more focused sets of deliverables to reduce the amount of time between client interactions, design and feedback. Most importantly, it begins to mentally sever the connection between boxing and the designer/client working relationship. The process of iterating has helped me to involve the client sooner and increased the quality of those interactions.
Using iterations, not rounds, has also created more efficiencies in my workflows. Every design problem is different and commands a different solution. Being able to work quickly through these potential solutions with the client affords me the opportunity to deliver a more thoughtful and stronger end-product.
There are many techniques (old and new), that facilitate iterating like using element or style boards, or the use of design management tools like Basecamp and Invision that provide an easy-to-use framework for accepting and delivering feedback. I've found that the most positive results have come from unpacking the design process and redelivering it using smaller, more digestible chunks. Rather than spending weeks creating full-comps to perfection with little client input, I now breakdown the design into sets of small components. For example: discussions on functionality and style, aided by a sample single-page to show context.
It's more logical and faster to iterate on smaller components—in this case, quick revisions to blueprint and style—than to revise an entire full-comp that took 3 weeks to create.
Unpacking the design process can look something like this:
Architect: Organizing of content hierarchy and prioritization. (Iterate.)
Blueprint: Key tools, functions, flow that the user/customer will use to interact with the end-product and how it lives together. Context is provided.
Style: Typography, visualizing attributes, color, textures, etc. I like to combine function and style discussions and provide some context.
(Iterate. Client feedback is focused on functionality and style preferences.)
Design: With a blueprint established, functionality and style preferences are applied to achieve larger design goals. Prototypes, full-comp pages are presented for context.
(Iterate. Feedback provided is more detailed and rigorous and sets up the final approval.)
Context (or visualization), is provided throughout all steps of process, but on a smaller, more frequent scale.
This type of framework can help the client to digest the various aspects of the design process and better understand how all the many small decisions contribute to and influence the larger end-product.
I'm not saying this is the solution to eliminating all hurdles between designers and the people they work with, but if we can start to reimagine how we communicate to the people who hire us, we can more effectively show how design can be used to achieve goals and solve real problems. An iterative method allows designers to step out of the ring, take the gloves off, and invite people into the process of creating something together.