Cart () Loading...

    • Quantity:
    • Delivery:
    • Dates:
    • Location:


Meet Customers' Needs Through Agile Team Development

Oct. 26, 2012
Alan Koch

We already covered the first three of the twelve advantages of Agile software development. These three advantages focus on team development and refining the process.

Advantage #4: Motivated Development Team

The positive relationship with a reasonable and satisfied customer is only one of the reasons why many developers prefer to work on Agile projects. The other main contributor is that they tend to value working in self directed teams (which the Agile methods require for success).

Agile projects are not planned by a Project Manager, the customer, an executive, or anyone else. The Agile team plans their own work, and then works their own plan (and don’t forget that the Customer is counted as a member of this team!) The dynamics are simple.

  • The Customer makes sure that they end up with what is needed

  • The developers figure out what it will take to make that happen

  • Issues, complications, and trade-offs are discussed openly

  • Compromises are negotiated and embraced by the team

In the end, the team (both developers and customer) own the plan and are responsible for its success. When corrective action needs to be taken, there are no fingers to point. “Our plan is wrong. We need to do something about it.”

Self-directed teams have long been recognized and provide a good environment for any kind of knowledge work. Software development is clearly knowledge-work, so it is surprising that it is so rarely done in self-directed teams. Most software developers appreciate the trust and respect that is implied when management empowers them to operate as a self-directed team.

Advantage #5: Productive Development Team

Of course, a motivated team (Advantage #4) is a productive team. But Agile teams are productive for reasons that go far beyond mere happiness! The Agile methods include several practices that enhance productivity.

On traditional projects, milestones tend to be few and far between. Agile projects have a significant milestone at the end of every iteration (every few weeks) — delivery of working software for customer acceptance. Because there is always a deadline staring them in the face, an Agile team can never afford to slack off. They are always driving toward a deadline that is relatively near.

Another productivity-enhancer is that Agile developers focus on working to “pay down” technical debt. Technical debt takes many forms on software projects, including these:

  • Technical questions or unknowns that are left unresolved. Agile developers will attack these things early in the project to eliminate the uncertainty that can balloon into missed deadlines.

  • Design errors that are left uncorrected. Agile developers will refactor working code to keep it malleable so they can continue incremental development, rather than coding around problems and postponing the day of reckoning.

  • Testing left for later. Agile developers fully and completely test their code as they write it, and do not consider coding to be “done” until all tests pass. They do not count on testers or anyone else to catch their defects, which can result in protracted testing phases at the end of the project.

In “paying down” technical debt, Agile developers make relatively small investments of time early in their projects to avoid the big timer-wasters later on.

Finally, the collaborative nature of an Agile development team means that each and every member of the team is learning from his or her peers continuously. Generalists become more generally capable, and specialists learn about each other’s areas of specialty. In this way, each Agile project produces value that goes far beyond the product for the customer. Each and every team member becomes more and more capable with each Agile project.

Advantage #6: Refined Processes

Most of us recognize that a “Lessons Learned” exercise can be valuable. But how often do they happen on our projects? With rare exceptions, in spite of the value we know these exercises provide, somehow we can’t make them happen on a regular basis.

Agile project teams hold a Retrospective (a mini-Lessons Learned) at the end of each iteration of every project. Because it is just a natural part of the process, it does not get skipped or preempted. And because it happens regularly, Agile project teams derive greater value from their retrospectives than organizations that actually do a Lessons Learned on every project.

As a part of the transition from one iteration of work to the next, the Agile team will ask themselves these questions:

  • What worked well for us in this iteration? How can we be sure to keep doing it?

  • What was problematic for us in this iteration? How can we fix it?

  • What do we not understand about something in this iteration? How can we learn about it?

  • What did we do differently in this iteration than before? Should we keep the change or go back to the

  • old way?

In other words, Agile teams are engaging in the most effective form of continual process improvement that you are likely to see in the software world.

The net result of this simple exercise every few weeks is that an Agile team will very quickly refine their processes. Ineffective practices will be replaced with better ones, effective practices will be strengthened, and problems will be solved.

Excerpted and available for download from Global Knowledge White Paper: 12 Advantages of Agile Software Development

Related Courses
Agile Boot Camp
An Overview of Agile Project Management
Agile for Product Owners