We here at buildonline believe in the power of systems and processes to build great software. Through study and experience, we’ve developed our own workflow that we use on all of our projects.
This workflow enables us to build fast, build right, and most importantly build the right things.
Our workflow is cyclical framework. We try to make sure that these cycles last less than three months. At the end of three months, you should have a functioning piece of software that has been thoroughly thought through, designed, built, tested and deployed to production.
Why a three month limit? Projects that drag on longer than three months are demoralizing for everyone involved. Time is money, and a project that takes six months to build means a project that waits six months for actual user feedback.
We can usually get from idea to MVP in three months, or from MVP to V1 or V2 in the same time if we are disciplined about thinking through what we are building and why we are building it.
Building software is all about finding the right people and getting them to make the right contribution at the right time in the process. These are the people who are a part of each build cycle:
1. The Client
The client helps throughout the process. At the beginning of the build cycle, during the discovery sprint, the client works with the project owner, designers and a project coordinator to think through the entire build cycle, identify features, and map out the project. The client is given the tools he/she needs to make informed decisions about what will and will not be built, how long it will take and how much it will cost.
Throughout the build cycle, the client is involved in several short progress meetings every week with the project owner or project coordinator. He/She knows exactly how many hours have been worked, what is being worked on now, and what is coming up next. The client’s input is welcome throughout the process.
2. The Project Owner
The project owner leads the design and development teams through the build cycle. His job is to help shape the work and break it down. Project owners most have wide knowledge about project management, user experience design and application development . They must be able to see the project from start to finish and work as a translator for the clients vision to the people actually doing the work.
Project owners meet with everyone on the project every week. They maintain a backlog of tasks that designers and developers can understand and execute and decide when those tasks need to be executed.
3. The Project Coordinator
The job of the project coordinator is to make sure that the project owner and client’s vision is being executed in a timely fashion. They meet daily with the designers to discuss the work and then weekly with the client for progress updates.
To borrow from the construction world, the project owner is like the architect or general contractor overseeing the project. The project coordinator is like a foreman who is on the job site every day, making sure the work gets done and done right.
Designers are involved in the first half of the project. They meet with the client, understand the client’s vision and turn low-fi wireframes developed by the client and project owner into screens and hi-fi clickable prototypes.
Designers are usually only involved in the first part of a project. Once features are decided and prototypes of those features have been made, designers move on to other projects.
Developers are the people who turn prototypes into working applications. Development is a slow process that takes people who are both creative and very knowledgeable.
Developers work best when they know exactly what the app should do, and so developers usually come into the project after most of the decisions about what it should do and how it should look have been decided.
The Build Cycle
The build cycle has three main stages, with each stage having it’s own deliverables:
The discovery stage is a two week sprint at the beginning of a build cycle.
The discovery stage kicks off with the client, the Project Owner, Project Coordinator and a Designer having an in-person meeting for one to three days. The purpose of this meeting is to discuss what to build and why it should be built. The goal is to identify a list of features for this build cycle and understand why these features are important.
At the end of the discovery meeting, the team will spend the rest of the discovery sprint creating wireframes for the features and then scope mapping those features into tasks with estimates for the designers and developers.
• A list of features to build
• Low-fi wireframes for the features
• A scope map/backlog of tasks for designers/developers
• A high and low estimate for how many hours the project will take to complete.
The design phrase takes one to two sprints (2 to 4 weeks). During the design phase, designers take the low-fi wireframes and turn them into a hi-fidelity prototype. This prototype will be a clickable, useable approximation of how the application will work. At the end of the design sprint, before we start development, we can put this prototype in front of actual users and get feedback so we know if any changes need to be made before going into the development phase.
If the project is an MVP, we also create a landing page using this prototype and start collecting emails and user feedback. We suggest you use these emails to build a newsletter and start building up anticipation for the launch of the app.
• All feature screens designed
• A clickable, shareable prototype
• Initial user testing (using the prototype)
• A landing page for gauging interest and building anticipation.
The development phase takes two to four sprints (4 to 8 weeks) and is where we build the actual application. Because we already have the project broken into concrete tasks and because we have a prototype, our developers will know exactly what they need to build. We will give you several progress reports every week and access to a staging server where you can test the application as it is developed.
There should be no surprises here. Because of the discovery and design stage, we should have a good idea how long it will development will take (in a range of billable hours) and the client will be communicated with regularly.
Once everything from the scope map/backlog is finished, the cycle will be complete.
• A working application in production
• Suggested future features
Usually, the client will have new ideas and features for the software and the cycle will start again. As we restart the cycle, going back into the discovery phase, the developers will be available to do some chores, tweaks and bug fixes.