Build in Increments

Scaling Agile Software Development

Traditional large software development projects are risky. They are notoriously hard to estimate and have a high rate of failure. We mitigate the risk of large scale development by building every system as a series of small things. Using the Agile methodology, we deliver working software iteratively. We work with our customer to prioritize features, and we build the most important features first. The system grows more sophisticated and feature-rich with each iteration, but each iteration can stand on its own. The small things we build grow organically into complex systems.

Large-scale Agile software development adheres to the basic principles of Agile:

  • Business and technical experts work together on small, cohesive teams
  • Definition of done is decided upon at the beginning of the project
  • Test-driven development keeps code clean
  • Development cycles are short
  • Feedback from real users influences subsequent development

Scaling agile software development means we break a large, complex project into small, simple components. The customer tells us which are most important to address and in what order. Basic functionality usually gets built first; bells and whistles are added later.

Simple and Fast

By keeping things small, we keep them simple, and we build them fast. If a concept turns out to be flawed, we find out quickly and learn from the failure. These “failures” very often result from the difficulty of translating vision into reality. Sometimes developers don’t quite understand what customers want, but very often customers can’t know exactly what they want until they see it expressed in software. The software may do exactly what was asked of it, but not, it turns out, what was really needed.

By breaking the problem into small chunks, we can test assumptions thoroughly and correct course quickly.

Large Scale Agile Architecture

In large scale agile development, an architectural vision and direction are established at the outset but the details are worked out through modeling and testing by the whole team as the project proceeds. Iterative and collaborative elaboration results in a more robust architecture than “big design up front” achieves.