Iterative Value

Agile in an agile way

Just about every software development company says they're “agile” today. We’re a bit different in that we’ve been agile innovators since the beginning. We do agile how it was meant to be done, in a way that provides you with the optimal collaborative experience.

We use our own agile approach honed by experience. That approach is significantly different from one dividing work into waterfall steps that need to be finished before moving on to the next one.

We focus on delivering working software early and often. For example, we don’t design architecture or UX first, all at the beginning of the project. Instead, we start those early and build the basics of your system into what we call a walking skeleton, which is an end-to-end exploration of some major pieces of your system without going as deep as we ultimately will.

Doing things this way prevents preoccupation with pictures and thoughts that don’t run. We’ve found it wiser to get to working software as soon as possible, then steer and refine.

We focus on extracting every ounce of value from multiple, tight, interacting feedback loops. That dramatically improves your odds of getting the software you end up wanting when the project is done, not what you thought you wanted when you started.

Working Iteratively with Confidence

Throughout the course of the project, we expect to collectively learn new things about the business model and the Product Owner’s release objectives. We expect the iteration plan to change based on the team’s learning and refinement of objectives. As changes, blockers, and unexpected challenges arise, the collective team (RoleModel and you) will evaluate appropriate next steps and make modifications to the remaining project activities and timeline.

To increase our confidence and ability to refactor and change the codebase we use a Test Driven Development (TDD) approach to create small feedback loops which help ensure we are building a solid foundation for your codebase. When starting new features we focus on the simplest increment of value addressing the business need, and we aim to ship that small increment. We’ll then iterate, as needed, with feedback from users and the Product Owner.

While adding small increments of functionality to the codebase, we are also building up a suite of automated tests at multiple levels (user and system) that exist alongside the production code. The documentation that these tests provide ensures the business needs for the software are encoded in the software.

These automated tests become a safety net to ensure we aren’t breaking existing behavior when adding new features, and allow us to refactor with confidence. In addition to automated tests, our development team does exploratory testing on each feature we deliver. Whether from our exploratory testing or customer user acceptance testing, as edge-cases or bugs are discovered we encode those as automated tests so we don’t hit that same case again.

Iterative Approach

We will deliver working software in each iteration, sometimes on a daily basis during each iteration. That lets you and your user community steer our work toward the software you end up wanting by the time the project is done. Our goal is to help you create a Minimum Viable Product (MVP), representing the most concise set of operational software features necessary for your users to accomplish their goals.

As we create your software, our software craftsmanship team writes automated tests based on feature definitions, and continually updates that test suite throughout the project as your system grows and changes. Passing tests tell the team when a feature is “done” according to your success criteria. The running test suite provides the team with extreme confidence to change the system in the future, knowing that the tests will catch any breaking changes. 

We collaborate with you as we write tests, get them to pass, and enable you to release incrementally, starting with your MVP and moving through your release plan to realize more business value.

We favor open, transparent, frequent communication as part of our collaborative software development. We track all work related to a project on a secure project-specific Trello board. For communication related to project work, we use a combination of Trello comments, a private Slack channel, and daily standup meetings

User Focused Design

You need software tailored to your users’ unique needs and workflows. We keep that in view from the start of a project, by rapidly prototyping and testing with the actual people in the real world.

That typically starts with validating rough sketches, then moves on to prototypes in the first couple of days on a project. We’ll keep that process going until your MVP goes live.

We use an agile approach for creating systems, focused on putting real software in the hands of real people as soon as we can to validate your direction. Instead of building a car one piece at a time (which means you don’t have a useful vehicle until the end), we create working software that gets more sophisticated and feature-rich along the way.

Our UX (user experience design)  approach is similar, always focused on working software, and not just pictures. If you don’t have every user view figured out before your project starts, that’s fine. We can help you drive from ideas to working software quickly.

As a quick example, on a recent project we started by imagining possible user iterations on a whiteboard. Then we transformed those rough sketches into low-fidelity grayscale mockups. Finally, we created working user views with a more polished structure, branding, etc.

The process from rough sketch to working user views with an actual system behind them (albeit simple at this stage) took 2 weeks.