Appendix A: Lean-Agile Job Tasks for the Producers

Job Tasks for Lean-Agile Development Teams

This section is aimed at training professionals. To better articulate our discoveries about what was really needed on the job for people transitioning to Lean-Agile, we performed a task analysis and developed the following Task List of things people need to be able to do using Lean-Agile on courseware product development projects.

You may need some of these, and others that are not listed. Use this as a start point and adapt for your unique circumstances. You will have to add the training design and development tasks yourself. This is only the Lean-Agile tasks that supplement the training design and development tasks.

Lean-Agile Task List for Learning Experience Development

Conduct High-Level Planning Tasks

High-level planning applies to the entire project, not to only one iteration.

  1. Gather information.

    1. Review existing information.

    2. Review any existing analysis artifacts.

  2. Make workflow transparent and visual.

    1. Define your workflow steps needed to produce learning experiences.

      Note
      Lean-Agile does not dictate your process steps.
    2. Create a Kanban board with these process steps as columns.

    3. Define the process steps or workflow on the board.

    4. Define "done" for each process step.

    5. Post done definitions under each process step column on the board.

    6. Apply work in process (WIP) limits to reduce cycle time.

  3. Orient team members.

    1. Clarify Lean-Agile modifications to normal roles in training development.

    2. Use generic Lean-Agile terms rather than from a specific framework.

    3. Conduct Lean-Agile training as needed.

    4. Clarify expectations for built-in quality of work.

    5. Ensure all involved understand what "done" means for each process step.

    6. Identify required conventions, standards or guidelines.

    7. Select more stringent criteria for quality as the team matures.

    8. Establish team ground rules.

      The following is not comprehensive, but only an example of a few: (a) Everybody works, (b) Pull the next highest priority work item card, (c) Use Kanban card avatar to visually signal ownership to others on the team, (d) Share stakeholder feedback with the team.

    9. Clarify job specialization expectations (instructional/LX designers versus media for example).

  4. Determine if design can be done during iterations or if a CDD (course design document) is required.

  5. Generate requirements (crucial for games or simulations).

  6. Conduct high-level design iterations (if you can do them in your circumstances).

    1. Determine how many iterations time and budget allow.

    2. Generate learning objectives (LOs) from the analysis task list.

    3. Determine evaluation strategy for those LOs.

    4. Get buy-in from SMEs and stakeholders on LO scope and sequencing.

    5. Generate initial ideas for instructional strategies.

    6. Collaborate with SMEs/Stakeholders about instructional strategies.

    7. Create the CDD (courseware design document) (just like in ADDIE) if prototype primacy is not agreed upon with customer.

    8. Complete the test-case checklist for CDDs as the definition of "done".

    9. Create the game or simulation design document (if applicable).

    10. Rapidly prototype.

      1. Determine how many iterations time and budget allow.

      2. Assume that first decisions will not be valid and that early design work will be discarded.

      3. Create prototypes over excessive documentation (to the degree the customer allows) to help stakeholders visualize the end state better.

      4. Prepare only representative content and call it a "functional prototype" not a "sample lesson prototype" so that the focus is on the functionality rather than the content.

      5. Demonstrate the prototype in a synchronous (group-paced) meeting to get quick feedback.

      6. Complete a prototype checklist with specific test cases as the definition of "done" for consistent built-in quality.

  7. Identify the initial courseware backlog.

    1. Decompose the training product (courseware) into a product backlog.

    2. Prepare Kanban cards for each work item.

    3. Prioritize based on customer value, risk and opportunity.

    4. Articulate why prioritizing high risk work items first reduces risk for all involved.

    5. Order the backlog so the highest priority work item cards are at the top of the stack.

  8. Setup development tools (non-recurring).

Tasks to Plan the Iteration

The following producer job tasks plan only the one iteration.

  1. Apply lessons from prior iterations.

  2. Use two-week fixed iterations to limit risk and complexity.

  3. Commit to an iteration goal (scope) and include it as a deliverable card type.

  4. Create the Iteration Backlog.

    1. Pull work item cards from the courseware product backlog to this iteration’s backlog.

    2. Add any required tasks to the backlog.

    3. For each learning objective, add its components as work item cards.

    4. Decompose the effort into similarly-sized work items (LOs rather than lessons).

    5. Break down high-level work items further into items small enough to be completed in a single iteration.

    6. Estimate the work items sizes, if not using historical metrics.

  5. Complete the iteration planning checklist.

Tasks to Conduct this Iteration

The following producer job tasks conduct only the one iteration.

  1. Apply Kanban.

    1. Apply Lean visual management for transparency.

    2. Pull Kanban cards from upstream, rather than push them downstream to get appropriate buffers between process steps, which in turn reduce bottlenecks (see Theory of Constraints for why).

  2. Synchronize the team every day in a daily standup meeting.

    1. Conduct daily standup synchronization meetings (use checklist if new).

    2. Use visual feedback from the Kanban board to improve.

    3. Establish a regular cadence (aka takt time, tempo, team pace).

    4. Match the cadence to the team’s capability to reliably deliver the working product increments at a dependable speed.[1]

    5. Reduce coordination costs (time box meetings to prevent waste).

    6. Collaborate during an iteration.

    7. Complete work items you pulled.

  3. Inspect and adapt toward the iteration goal.

    1. Meet the expected cadence.

    2. Inspect artifacts and progress to detect issues at the point of work (gemba).

    3. Optimize for team throughput over individual performance (this takes a lot of persuading to some people initially).

    4. Continually implement the highest-priority work items from the backlog to ensure what you deliver will be the highest value possible even if some of the original backlog work items are different by the end (this only works if your customer contract allows for it).

    5. Prevent changes during a fixed iteration that endanger the iteration goal.

    6. Reduce cycle time—Use it as a good approximation of effectiveness

      • Use small batch sizes and one-piece flow.

      • Apply the Theory of Constraints to remove bottlenecks.

      • Free up resources to fix the bottleneck.

      • Remove blockages actively.

      • Reduce transaction costs to facilitate doing smaller batches cost effectively.

      • Apply WIP limits to minimize context switching waste.

    7. Lean out waste.

      • Reduce setup time.

      • Identify anything that (a) delays the start of work, (b) interrupts work, (c) requires ramp up to "full speed", or (d) is similar to or identical to another task.

      • Offload interruptive and delaying tasks if possible.

      • Streamline or automate tasks.

      • Use Lean problem-solving tools.

    8. Standardize to reduce complexity, reduce task variance (i.e. Standard Work).

    9. Focus efforts on variables that regulate throughput per Little’s Law: WIP and cycle time.

    10. Apply Lean principles.

    11. Increase the degree of employee participation in improvement and increase team self-management through information sharing.

  4. Analyze components (this may just be requirements generation at the component level).

  5. Design components (elements of ADDIE still apply here, do one learning objective at a time for one-piece flow).

  6. Develop components (elements of ADDIE still apply here, done one learning objective at a time for one-piece flow).

  7. Test components.

    1. Perform automated tests.

      • Perform spell check.

      • Find more ways to automate testing.

    2. Perform manual tests

      • Complete checklist for accessibility compliance (Section 508).

      • Confirm text content conforms to the project style guide.

      • Complete test case checklist to ensure the User Interface (UI) works as intended.

      • Complete functionality and content checklist for UI tutorial and help screens.

      • Complete functionality and content checklist for xAPI (if applicable).

      • Complete test case checklist for SCORM (if applicable).

      • Confirm level of interactivity is met (if contractually required).

      • Complete content for instructional/LX design validation.

      • Complete functionality and content checklist for learner assessment test bank.

      • Complete content checklist for storyboards/scripts.

      • Playtest game and simulation components.

  8. Integrate components in to the courseware build, authoring tool or learning content management system (depends on project).

Tasks to Deliver the Iteration Results

  1. Deliver this iteration’s results.

    1. Deliver a working product increment each iteration.

    2. Check customer satisfaction with the product increment.

    3. Facilitate an iteration review/demo.

      1. Provide the working increment to stakeholders.

      2. Review the iteration goal.

      3. Discuss any variance from the iteration goal, root cause and recovery plan.

      4. Ensure the team demonstrates the work it has "done" and listens for feedback.

      5. Capture review minutes and share with the stakeholders.

    4. Confirm how close we are to the customer’s intent.

    5. Use different colored Kanban cards for defects or change requests (CRs) - we use orange.

Tasks to Conduct the Iteration Retrospective

The following producer job tasks conduct the retrospective for this iteration.

  1. Conduct this iteration’s retrospective.

    1. Inspect how the last iteration went with regards to people, relationships, process and tools.

    2. Capture iteration lessons learned.

    3. Develop a plan for applying improvements to the team’s process.

    4. Apply Kaizen, continual improvement (get a little better each iteration).

    5. Discuss work in process (WIP) limits.

    6. Measure change requests (CRs) and defects.

      1. Measure CRs/defects generated (rate per iteration).

      2. Measure CRs/defects resolved (rate per iteration).

      3. Measure CRs/defects open today (quality).

      4. Measure CRs/defects that escaped this iteration.

    7. Measure unfinished work items during the iteration.

    8. Measure productivity per student seat hour (at the end of the project).

    9. Complete the iteration retrospective checklist.

  2. Apply review/demo feedback to improve and optimize the team’s performance.

    1. Apply lessons learned from prior iterations to next iterations.

    2. Add new work items (new scope demand).

    3. Transfer unfinished work items to the courseware backlog for another iteration.

    4. Optimize for the entire development process level over individual efficiencies.

So in summary, there is a proposed current task list. This can help you train your teams to be able to do these tasks. They probably won’t know the Theory of Constraints or be able to apply it on their first iteration, but as the team matures, they need to know how to apply this theory too.


1. Reproduced from Wikipedia article https://en.wikipedia.org/wiki/Scrum_(software_development) under a Creative Commons Attribution-ShareAlike 3.0 license.
Image

Line By Line

Here a Little, There a Little, Layer by Layer.

Back to Overview