Development cycle

We try to be very flexible in terms of choosing an appropriate software development life cycle model for each project. Our preferred model is Extreme Programming as it allows our clients to refine specification early in the cycle and, more importantly, they get a working prototype to play with. This allows our clients to envision the result and pinpoint the features they forgot to mention in the requirements and specification phase.

The development cycle usually looks like this:

  • Gather requirements from the client

  • Design and approve the specification

  • Prototype (this phase ends with client getting a working prototype of the future system)

  • Iterative and incremental development (see below)

  • Feature freeze

  • Final testing and revising documentation

  • Code and documentation freeze

  • Release & Deployment

  • Support and further improvement of the system (repeating steps from Iterative and incremental development)

The most important phase is iterative and incremental development, which is done in iterations that last from 1 to 5 weeks, depending on project size. Each iteration consists of the following steps:

  • Client prioritizes tasks in current iteration plan (which was sent to him on a previous iteration) and adds new features (which he also prioritizes) that he wants to be developed on a current iteration, along with setting an overall goal for the iteration which will help us to better select tasks.

  • We receive iteration plan from the client and estimate how long each new feature will take (in man-hours).

  • Then all tasks are assigned to individual developers in order of their priority. If the iteration has an overall goal, some lower priority tasks may be reprioritized to better align with the goal.

  • Iteration plan is sent to the client for consideration. If the client has some corrections, they are incorporated into the iteration plan.

  • After an iteration plan is agreed upon, it remains unchanged for the remainder of the current iteration. However, if there is remaining time during the iteration, after all features have been delivered, the team will contact the client to consider the additional features that should be developed during the iteration. If, on the other hand, it becomes obvious that it is impossible to deliver all the features during the current iteration, the client will be asked to determine which features should be delivered first.

  • During the iteration, all tasks are done according to the agreed plan; the code is built daily and automatically tested with unit tests.

  • At the end of iteration an updated plan, which contains details of the current iteration, is sent to client for the next correction and prioritization.

It is paramount for clients to decide what they want done in the current iteration by assigning appropriate priorities to each task. Knowing how long a task takes to complete (and thus how much it will cost) and their priorities on different tasks, clients will usually have a better notion of which tasks should be done first.

This iterative approach helps our clients add additional features that were not accounted for in the initial specification. However, some clients prefer a less formal approach that requires less of their involvement. This approach makes sense for small projects, in which case, we do all the formal procedures internally and just consult client on general priority of features.

Regardless of development cycle, our clients receive periodic (daily or weekly) status reports with details on the progress of the work and the deadlines met. That makes our development process transparent to the client and allows for more client control.