Learn stages and skills
This page discusses the usage of Advanced Roadmaps live plans. If you're using the redesigned planning interface, see this page instead.
Stages are activities that are done sequentially per work item. In a typical release, there are several work stages that could happen in a sequence.
For example, let's say your team works according to the following stages:
- Stage 1 is Design, where designers brainstorm and come up with the product design, based on the product and user requirements that have been scoped
- Stage 2 is Implementation, where developers now create or update the software, based on the design that's decided in stage 1.
- Stage 3 is Testing, where quality engineers then test the software, based on agreed scope, requirements, and design.
Another example, let's say your team estimates work in hours and days, and uses the following stages:
- Stage 1, where the product owner writes the story
- Stage 2, where the cross-functional Scrum team handles the implementation
Skills, on the other hand, are abilities that team members must have in order to complete work items. Skills can be defined per stage and allow to categorize different types of work within a stage.
Skills are useful in cases where the team's members abilities can cause bottlenecks in planning. You will have to take into account that your team has the appropriate specializations.
For example, let's say in the design stage, you need the following skills:
- UI design, which pertains to UX design skills
- Frontend architecture, which pertains to frontend development skills
To create a stage:
- In your plan, click more (
) next to the plan name > Configure > Stages and skills. - Click Add stage.
- Enter a name for the new stage.
If necessary, change the color for the stage by clicking on the color ball and selecting a new color.
- Click Add stage.
To create a skill:
- In your plan, click more () next to the plan name > Configure > Stages and skills.
- Click Add skill.
- Enter a name of the skill, and click Create skill.
Set the percentage for the estimate allocation of the skill.
The estimate allocation will define the percentage of that skill that someone needs to complete that issue.For example, if an issue has a total estimate of 10 points, and the implementation stage has two (2) skills visual design and coding, and each skill is 50% of the stage, this would happen: 5 points of the total estimate would require a person with visual design skills, and the remaining 5 points would require a person with coding skills.
Once you've created a set of skills, you can add them to the stages.
To delete a skill, hover over the skill > click more (
) > Delete.
Some examples of using stages and skills in teams
In this example, you have a fully cross-functional Scrum team — everyone in the team can do all types of work required to implement a user story.
You have the following stages:
- Stage 1, where the product owner writes the user story
- Stage 2, where the team implements the user story. All activities, such as UI design, coding, testing, and more are done within the same iteration.
Configuring stages will be very simple in this case. You just need to add two (2) stages, without any skills.
Anyone in the team can take over any implementation task, so everyone will have the implementation skill:
The resulting schedule will then look like this when some stories are added. The story writing stage will be scheduled at least one sprint before the implementation stage. However, this doesn't apply to stories that don't required any story writing effort.
If you prefer not to estimate and reflect any story writing effort in your capacity plan, and instead plan for story writing separately, you can choose to leave out the story writing stage altogether.
In this case, the following will happen:
- Story writing effort is not planned in Advanced Roadmaps.
- Implementation effort is planned in Advanced Roadmaps, and implementation is becomes stage 1.
- Since it's the product owner that handles story writing, you no longer need to include the product owner in the capacity plan, as shown below:
Advanced Roadmaps will now work out the scheduled based on the assumption that all required input (user stories, requirements, etc) will be available for the team as soon as the stories are scheduled.
Although you can plan activities separately, we recommend that you include all types of effort, stages, and skills in your plan. One of the common challenges many teams see in their organization is being realistic and explicit about design work and user story writing. Having a single source of truth for all teams to see can help align effort — and Advanced Roadmaps can help your team achieve this better if all aspects are included in your plan.
Let's say that in your team, everyone can take over some tasks, such as testing — but then, only specific members have the skills to take on design, coding, and dev test.
To handle this in your plan, you can add the specializations as skills for the corresponding stage, which is implementation in this example.
After which, you can then assign the skills for each of the team members:
Let's say your team doesn't work in fixed iterations — and that they work on a day-to-day schedule, pulling in work from a backlog when tasks are completed. In this case, their work would be structured into design, implementation and testing – and these happen sequentially per work item. However, rather than waiting for the next iteration to start with the next stage of work, implementation can actually start on the right after design has been completed.
For this example, you can set it up this way in Advanced Roadmaps:
- Switch the team schedule to Kanban mode
- Define 3 stages, which are design, implementation, and test in this example
- Add specializations for the stages where needed, which are frontend, backend, and data management in this example
The schedule will look different for Kanban teams, with the stages scheduled sequentially per item. If there are free capacities, multiple stories can then be scheduled in parallel. The focus here would be completing stories end-to-end, from design through testing, in the shortest possible time.