Every project begins with a discovery phase. This is where we sit with you, your team and all the project stakeholders to understand the business objectives of the product you want to build. We strive to go beyond the 'How' and address the 'Why'.
Once we've identified the particular pain point that you want to eliminate, we start to gather all the requirements that relate to your objectives. At this stage, we seek every perspective possible and assess every detail in depth.
We complete this phase when we're confident that we can deliver a technology solution that not only meets all your current business objectives but also expands your opportunity for growth.
This is where the fun happens. We take the learnings and requirements from the discovery phase and design a solution that delivers on our promise of a cost-effective, future-proof technology that addresses your core business objectives.
In this phase we architect all the components of your application from code to cloud. On the front-end, these include items such as UI / UX workflows, sitemaps, wireframes and mockups. On the backend, we define the data models, APIs, storage management, communication channels and security protocols that will allow your app to function and scale as your business grows.
Our design process doesn't occur in a black box. Rather, we are in constant contact with you to receive your feedback on our approach. Your feedback is critical as it informs our process to ensure that what is utlimately developed meets and exceeds your expectations.
Once business requirements have been translated into a set of physical, logical and visual blueprints, we create a comprehensive project plan to organize and manage the development effort. We follow an Agile model where the project is broken down into one or two week development cycles (called Sprints). The goal of each Sprint is to end with a working system that we can demo to you for your feedback.
As in the design phase, we rely on your input during each Sprint cycle to make sure our development is aligned with your business objectives and to make any course corrections if necessary.
A fact of software is that all code has bugs. When it comes to creating apps with any degree of complexity, what differentiates the best development teams from the rest are the testing processes that are followed to find and fix those bugs quickly.
To ensure we deliver applications of the highest quality, we layer tests on multiple different levels. Starting at the code level, we write automated Unit Tests which check that a particular piece of code does what it is supposed to do. The next level of testing is embedded directly in the Sprint cycle. These Functional Tests ensures that the functionality that was developed during the Sprint actually meets the specified business requirements.
At the end of each Sprint cycle, we add another layer of testing. These tests, known as Integration Tests, check that the combined functionality of all the software components developed to date are working correctly and, again, meet all the specified requirements.
These test cycles continue over the course of development. As bugs are found, they are captured and prioritized to get resolved in the current or next Sprint. As the project nears completion, we layer in another round of User Acceptance Tests (UAT) which involves you and your team. This is where you can access a fully functional system to validate that everything is working as it should. Any final bugs or issues identified during UAT will be resolved before the application is delivered to you.
Once the software has been developed and tested, the code is deployed to production. This where the application is available and ready to be used by your customers.
The deployment phase, however, does not imply the end of the development cycle. Once in production, the software will have to be maintained. These maintenance activities include upgrading various software components to address security issues, maintain compatibility with third party APIs, remain current with app store guidelines, etc.
In addition, as customers start to use the software there will likely be bugs that were not caught during the various testing cycles. These may also include design bugs where, for example, a button might have been included for an intended purpose, but which your customers find confusing or a nuisance. As with internal testing, these bugs will need to be captured and prioritized so they can be addressed in a future update.
Finally, once in the hands of your customers, you can expect requests for feature enhancements. These feature requests essentially begin the discovery phase for the next release of the software.