People come to us because they have great ideas but they don’t have the skills or the time to express those ideas in software. Our job is to translate their ideas into custom applications that look good, work well, and hold up to heavy usage.
It’s exciting to build something entirely new, but it can be risky. We mitigate the risk by:
Getting to Know You: Roadmapping
We start each new engagement with Roadmapping. We spend a few days with you documenting your high-level requirements and then we give you an educated estimate. We get a good handle on what you want, how to build it, and what it’s likely to cost.
Roadmapping results in standalone documentation that can help guide your custom application development no matter who does the coding. When you see our no-nonsense approach to planning, however, we think you’ll want to keep us on to do the building.
During Roadmapping, we:
Mind Meld: Agile Development
After Roadmapping, we have a general plan for building the system and we know where to start. But we also know that, as the system grows, you may want different things than you thought you would. So we don’t get too attached to our planning documents, and we don’t go too long without showing you how the system is shaping up. In fact, we don’t like to go more than a week without delivering the latest version of the system to you to test. In order to translate your ideas into working software, we need your near-constant feedback.
In Agile terminology, we have weekly Sprints:
Only by seeing new features in action will you know if they’re really what you had in mind. With just a week between builds, it is easy to make course corrections.
Short feedback cycles help all of us see what an idea looks like once it’s built – maybe it came out just as you expected, but maybe it turns out to be not such a good idea after all, or maybe it’s so great it inspires a whole new project focus. The Agile methodology lets us pivot to take advantage of these insights.
Step by Step: Behavior Driven Development and Integration Testing
To reduce risk, we build up complex systems from a series of small components. The components have uniform interfaces so they can work together. We use behavior driven development (a variety of test driven development). Before we build the component itself, we create automated tests to see if the component is behaving as expected. Naturally, the tests fail at first, but once we build the component, they succeed. We rerun the tests whenever a change is made. We also do integration testing to make sure all components work together, and we rerun these tests whenever a change is made as well. Modularized components and constant testing make defects easy to spot and correct.
We use a similar approach when we integrate existing third-party software – such as social media platforms or video streaming software – into your custom application. We teach our code to communicate with the third party software via its API (Application Programming Interface). Whenever a change is made, we test to make sure the integration is still successful.
Honesty is the Best Policy
Small or large, changes can affect the budget or the schedule, and we will lay that out for you right away, so you can manage the consequences. Honesty may require some difficult conversations at first but it quickly pays off in trust, effective communication, and the advantages of planning based on reality rather than wishful thinking.