Depending on the speed of the team, it can be determined how many story points the team can do per iteration. Iterations can last from one to three weeks. The focus here is on creating tasks and prioritizing them. The iterations also have the same phases as the earlier release planning, as follows:

• Exploration phase: During the research phase of iteration planning, the user stories are divided into tasks, and how long a task will take is estimated. The main activities in this phase include the following:
  • Translating the user story into tasks and writing them on task cards.
  • Adding or splitting tasks; in other words, if the developer cannot properly estimate how long a task will last because it is too big or too small, something will need to be altered.
  • Estimating the task, where an estimation of a task's execution is produced.
• Commitment phase: In the assignment phase of iteration planning, the following tasks are distributed among the developers:
  
  • A developer (programmer) accepts a task: Each developer takes a task for which they then become responsible.
  • The developer gives a time schedule: Because the developer is now responsible, they are now best able to give a time estimate.
  • The effective working time is determined, outlining the number of hours that a developer or programmer can develop during an iteration. (For example, in a 40-hour working week, in which five hours of meetings are held, the effective working time becomes 35 hours.)
  • Balancing: Once all the tasks have been assigned, the number of hours each developer has received is also compared to how many hours they actually have available (this is also known as the load factor). The tasks may then be redistributed to ensure that each developer has roughly the same amount of work. If a developer has too much work, something will have to shift.
• Steering phase: The execution of tasks is done during the execution, or steering phase, of iteration planning. There is a bit of a game element to this, but the following steps are advised:
  • Taking a task card: Here, the developer gets a card with the description of one of the tasks they have registered for.
  • Finding a partner: The developer looks for a partner to develop the task with.
  • Designing the task: If necessary, in this stage, a (short) design will be made.
  • Writing the unit test: Before any programming, all tests must be ready. Preferably, these are automatic tests because they often have to be done every time source code is checked in.
  • Writing the code: Here, the programmer or developer makes the program.
  • Testing the program: The unit tests are performed.
  • Refactoring: In this step, the refactoring rules are applied and the developers ensure their code meets the standards.
  • Doing functional and integration tests: After the unit test, all possible other tests are run, such as integration tests, regression tests, and so on. The code must be adjusted in this step until the test succeeds.