Creating Winning Teams

Use Case 2.0 Essentials Practice

  • A scalable, agile practice that uses use-cases to capture a set of requirements and drive the incremental development of a system to fulfill them.


    Practice Overview:

    Use this practice to capture requirements in an accessible form and drive the development of software. This practice allows teams to:

    • Describe exactly what a software system must do
    • Group parts of the requirements together for broad-brush scope management
    • Slice the requirements to create well-formed product backlog items and drive iterative development
    • Change the priority of what the customer wants at any time
    • Produce a simple visual model, and meaningful requirements, that are understandable to developers and customers alike
    • Realize the benefits of iterative and backlog-driven management practices such as Scrum, and the IJI Iterative Essentials
    • Capture their requirements just-in-time, and in just enough detail, to support their business goals.


    Things to Produce:

    This practice involves the production of a number of requirements, design and test artifacts:

    • A use-case based specification of the requirements, stories and test cases
    • The realization of the use cases to drive the development of the software
    • The generation of tests and test results to test the resulting system and record the results of the testing.

    Use Case 2.0 To Produce


    Key Competencies:

    The Use-Case 2.0 Essentials practice requires the team to be skilled in software requirements capture, design, coding, integration and testing.

    Use Case 2.0 Competencies

    The most important of these are the skills of the customer representative and the analyst as without these the wrong thing may well be developed and tested.


    Things to Do:

    The Use-Case 2.0 Essentials practice starts by finding actors and use cases, and selecting and prioritizing the parts (slices) of the use cases to be developed.

    Use Case 2.0 To Do

    It continues by detailing the use-cases slices and more importantly their tests, and then implementing software to meet the tests. It concludes by executing the tests, tracking progress in terms of verified, working software and feeding back the results in order to handle change and better support the team.