The client brief has been understood, the designs have been approved and the development is underway. Yet the project seems to drag on well past the delivery date. At times, clients find themselves in this position but for the life of them can not figure out what is wrong. The problem could be a mismatch between the designer and the developer.
The creative and the practical have always been at loggerheads. Conflicts between designers and developers arise due to contradictory views where the designer is focused on the look and feel and the developer on the functionality. If the conflict is not resolved quickly, it could very well take so long to finish the project that it becomes unprofitable for everyone involved. Let us now take a look at some of the issues that arise between designers and developers and how they can be resolved or avoided altogether.
Some 'failures' caused by designers
Excessive use of flash
Designers adore working in flash as it gives them a wide creative platform on which to create their designs. Through flash they can design the site to look exactly like they want with animations and effects. For some designers, using core web technologies severely limit their design possibilities. The issue that developers have with using too much flash is that it greatly increases the load time of a website and this, according to various studies, causes people to move away from the site.
Creating designs that cannot be used in web
At times, designers create great looking designs that cannot possibly implemented in web. This is usually due to their lack of knowledge of fundamental aspects of web technologies. Due to this lack of knowledge they sometimes create designs that are impossible or extremely difficult to implement on the web.
Creating PSDs that contain multiple unnamed layers
For a developer, receiving the PSD of a design with multiple unnamed layers can be a nightmare. As long as something looks good in the view port of Photoshop it is usually good enough for the designer but developers have to have their documents flowing in an organized, logical manner or their effectiveness decreases. As they code in logical sequences, working with disorganized and cluttered PSDs infuriates them and greatly increases their workload making it difficult for them to meet deadlines.
The designer failed to take into account the actual size of the finalized content
When designing a web page, designers very rarely use the actual content that will go on the page. Usually designs contain a paragraph of dummy content for each section and the rest of the page is designed with balanced module heights and columns. This causes them to make erroneous assumptions about the final output as when the time comes to put in the actual content, developers find that enough space has not been given and then the actual page ends up looking different from the designed comps.
The designer failed to mention the styles used
Developers sometimes receive comps with no explanation regarding styles used, margins, colors used, etc. This means that the developer has to use his best guess and code according to that. This not only takes up a lot of time and effort but can also cause the final output to look different from the design.
How designers can avoid these 'failures'
Explain the design rationale
Most issues can be avoided if the designer takes the time to sit down and explain the design and its rationale to the developer. This will allow the developer to understand the thought behind the design and will give them an opportunity to clarify any aspects of the design before they get started, thus making development smoother.
Practice PSD etiquette
Designers should ensure that they only provide PSDs that are clean and well organized. Further, they should use smart objects wherever possible as this will save the developer a lot of time and effort.
Designers should think thoroughly and design all aspects of the site including error messages, 404 pages, etc. This will save the developer a lot of time and ensures that there are no hold-ups once the development is underway.
Enlist a developer during ideation or when in doubt
Enlisting the help of a developer in the ideation stage or when the designer is in doubt about the technical implications of a project will save a lot of time and effort all around. Involving the developer at critical stages allows for the building of trust between the two and allows for more effective collaboration. It also allows the designer to only create those designs that can be effectively implemented. This is possibly the most important way to avoid failures between design and development and can lead to huge savings in terms of rework, time and money.
Learn at least a little about development
It is very critical for designers to learn at least the basics of web development as it enables them to know exactly what can or cannot be properly implemented on the web. Further, by knowing the fundamentals, the designer becomes more emphatic to the problems faced by developers and learns to take into account their point of view while creating their designs.
Some 'failures' caused by the developers
The finished site looks different from the designed comps
Designers, at times, are infuriated because they had given the perfect design to the developer but when the end product came back, it looked very different from their design. The important thing to remember here is that designed comps are not web pages. There are a lot of thing that can be done in Photoshop, Illustrator, etc. that can be impossible or very impractical to be replicated on the web. In these circumstances, the design will have to be scaled down to suit the web.
The colors used are different from the design
Sometimes designers find that the colors that they had used in the designs are not the same as the colors that the developer has implemented. This problem usually arises when the developer has used his best guess for the colors. This can be effectively avoided if the designer clearly spells out the values of the colors used on the page.
Loss of 'white space' due to cramming
Some developers do not understand the use of whitespace in improving readability and guiding the eye of the viewer. They tend to cram it all in an effort to save space and reduce the scrolling required. This causes the site to look cramped and cluttered and greatly diminishes the user experience on the site.
Overestimation of the time required for development
Developers tend to pad the effort required, in terms of time, to complete the site. This is usually done because there will always be some unexpected issues that arise. The website has to be compatible and look the same in different browsers which is a problem as different browsers follow different rules, hence the overestimation. Unfortunately this also means that the time required to complete the project also increases.
How developers can avoid these 'failures'
Be available to designers
Developers should take the time to clarify any technical queries a designer might have and also involve themselves in the ideation process. What this will achieve is design concepts that can be easily and seamlessly incorporated into the web. This will also build a better rapport with the designer and enable effective collaboration.
Provide Simplified explanations
It is important for developers to remember that designers are not technically proficient in web development and hence any explanations, be it clarifying a query or explaining why something cannot be done must be explained as simple as possible.
Develop all the little details
The design that a designer creates is the vision that they had for the site and hence every little detail is very important to them. It is essential that the developer incorporates all the little details while developing the site as something that may not be very important to them may be extremely important to the designer.
Explain properly and honestly if something cannot be implemented and why
There are things that designers create that cannot possibly be implemented on the web but unless a developer properly explains what these things are, the designers will continue to incorporate them in their designs. Further, if the developer does not explain why it cannot be done, the designer might think that the developer is just being lazy. Therefore it is essential that developers properly and honestly explain what aspects cannot be done on the web and this must be done right at the ideation stage as it will save both the designer and the developer valuable time and effort.
Learn at least a little about design
As a developer, learning the basics of design will allow them to better understand the vision and rationale of the designer and in turn will allow them to better implement the design. It will also build empathy towards the designers and will allow them to work closer together.
In the End
In the end it is important to both designers and developers to remember that they are part of the same team. They share the common goal of providing client satisfaction. They should collaborate during the ideation stage, while keeping an open mind, as this will save them a lot of time and effort. Checking in with each other often allows them to keep their eye on the big picture and ensures the project is on track. Remember to be nice and learn from each other as inspiration comes from the most unexpected places.