Building products is tough (and expensive). I’m always trying to find ways to speed up development but also have something tangible at the end of the process. Time and time again I see companies pouring money into their ‘Minimum Viable Product’ or ‘Proof of Concept’ only to be left with a prototype that is not much more than a wireframe and a huge pile of unreadable, undocumented code. The typical process I use when starting a new project is as follows:
- Research — Investigate the area and get a greater understanding of the field. Outline similar products/service and notable features.
Output: Research document
- Requirements — Discovery into what elements and functions are necessary for the initial iteration. Outlining list of features to be implemented in the alpha, beta and product phases.
Output: Functional requirements document.
- User experience design (UX)—Process of enhancing user satisfaction by improving the usability, ease of use and pleasure provided in the interaction between the user and the product. This area will produce a prototype with focus on interaction design and usability.
Output: Wireframe. Either interactive or in PDF format.
- User interface design (UI) — Actual look and feel design of the final graphical user interface (GUI).
Output: Illustrations and assets for development.
- Database design —Process of producing a detailed data model of the database. This logical data model contains all the needed logical and physical design choices and physical storage parameters needed to generate a design in a data definition language, which can then be used to create a database.
Output: Database schema document followed by implementation.
- Alpha development and testing — First complete version of the application to show what the product will do. Thought of as a ‘preview’ version.
Output: Testable version containing all features gathered.
- Beta development and testing — Product goes from functional to a polished, almost ready for release version.
Output: Refined version with all major bugs fixed.
- Production release — The final iteration that is pushed live to the public.
Output: Production ready application.
Depending on the type of product or service you are building, this process can range from weeks to months (if it is looking like years, then go back to step 2). What most people miss is that steps 3 (UX) and 4 (UI) can work in parallel with steps 5 (DB) and 6 (Alpha) by developing the first alpha version as an API. When you are ready to move onto building the front end, you can leverage this API by using libraries like AngularJS and Twitter Bootstrap to get going in no time.
This approach has number of advantages:
- Separation between ‘Front-end’ and ‘Back-end’ — By decoupling the data from the view, it encourages better architecture. It also makes it easy to push lots of different types of views, regardless of size.
- Modularity — Easily add or remove an API to decrease the difficulty of scaling up your application. If you need to add more servers, you can do so at a lower cost by spinning out more API instances and pushing logic to the client-side (front-end).
- Documentation —As the front end developers will have to leverage the API, the back end developers will be forced to provide documentation.
- 2 for 1 — If you wish to expand your offering and open up your APIs to the public, a lot of the hard work is done at minimal extra cost and time.
This is a brief intro into API First Development. I’ll be doing more posts over the next while breaking it down into more niche topics.