Many of you must have invested heavily on time as well as on money trying to develop mobile apps either for business, products or services. But you’ll often find a similar pattern of cost-overruns, code and asset blow up and development delays. The important question is why is this happening time and over again? What is the root cause and what could be the possible solution to it?
Why is history repeating itself?
There are a number of obstacles when it comes to building and designing mobile apps. There are many stakeholders involved in mobile app design process such as the designers, the production team, the marketers, their managers, and the customers who fund development but out of all of them very few actually understand how the app will work at the code level. Mostly the engineers are the ones who define the app creation process but usually there is lack of communication between the app planning phase and the development phase where the code is actually implemented.
How can we prevent these obstacles?
A lean, agile UX approach helps to solve such issues and obstacles. The process of application development needs to begin with an integrated design/development team and early stakeholder involvement along with a lead product manager driving the entire process. Lean practices save a lot of time and money to design, learn, and iterate. Presenting early designs in front of the dev team is extremely crucial to make sure the entire process of app development stays realistic. Good understanding and collaboration between all the stakeholders is crucial.
A Vision That Code cannot Complete
There are a number of prototyping platforms available in the market such as InVision, Origami, or Pixate, and powerful visualization tools too that express the look and feel of the final app. However, we need to understand that these prototyping platforms may be strong enough for the representation of the final look and feel of the app that may not even be feasible in reality, but one thing they lack is the direct relation to the underlying code. The app may be visually appealing but it may add months to the complete development. There is a major contrast with web-based design, where the final HTML/CSS code can be prototyped in real time.
The main problem arises when you put a design in front of a client, and the client gets stuck to that vision, and after weeks or months pass by, the client gets disappointed, when the final app is compared with the design that they initially they signed off.
Irony of Design and Resource Allocation
A prototype definitely helps in presenting the final look and feel of the application to the customers. It is an effective part of the process, through which the customer gets an idea of the app. Once the prototype has been finalized, the actual coding and implementation begins. The prototype now loses its value and most of the time is now spent on coding and development. The prototype finally gets discarded. It includes resources spent on designing that never materialise into the final app.
There exists a major disconnect between prototype and development. It is easy for a designer to come up with a great design without actually understanding the effort that will go into developing the same such as great animations, UI concepts and rich media content that are simply not possible to implement through code.
In such cases, the designing team’s effort as well as time is wasted, increasing new rounds of design when the issue is discovered and most often very long after the final prototype has already been approved, signed off and ultimately been handed over to development team.
The hazards of Designing without Real Data
Prototypes are generally designed first without checking how the data will respond to when fed to the app. During this process, designers tend to be selective and cherry pick numbers, names, data and images that best demonstrate how the final app will respond to ideal user inputs. They do not tend to consider real data or messy and wired user inputs that may make the app non functional or non responsive.
Unfortunately, specific data-versus-design problems are spotted very late or only after the app is in active beta testing, or in the worst case only after it’s in the App Store/Play Store and actual end users start using it. In such cases both the designers as well as the developers have to go through the entire cycle of iteration which is a costly and time-consuming in order to come up with an update.
Build Apps rather than Prototypes
Prototype is essential but it cannot be translated perfectly into the final app. There are challenges but every challenge has a solution. Some suggest that the solution is for designers to learn to code. May be designers need to learn what can and cannot be done, and to work closely with the coding team. But will it really be helpful? I think what is needed is a better understanding of the app as a whole, and the entire process, right from the basics of its analysis, planning, designing, programming and the UI/UX, within the context of the different platforms it will finally run on.
Point to be understood here is that the process of app building is not a very straightforward one. It involves lots of aspects. What is needed is a pure process where designers and developers collaborate with each other and work together harmoniously to create the company’s vision into a compelling and exciting reality.
Today where apps are increasingly becoming the ultimate reality of every company, business, or service, this collaborative and harmonious approach between the stakeholders involved in the app building process is of utter importance for the success of the app and for the growth of business on the whole.