By Nick Entin, VP R&D, Polarion Software
In the first article in this series, I talked about the reasons that led Polarion’s R&D team to adopt Scrum to manage the development of Polarion software solutions. In this article, I’ll discuss the benefits our team derives from…
Incremental Iterative Development
Traditional development supposes long-term planning in advance and performing all relevant activities before product hits the market. Scrum recommends a highly-adaptive way of development with short iterations producing fully tangible results.
- Shorten time to release to the market
- Transparency to management/customers
- Faster reaction to market needs; confidence of customers in Polarion’s development
- Simplifies synchronization of distributed teams
- Faster feedback from the field
- Easier releasing – smaller stabilization sprint, less things to test
- Flexibility in prioritization, risk reduction
All the Application Lifecycle (ALC) activities may be done in parallel because the specification of one feature, which could be implemented in the next iteration, can be done in parallel with implementation of another feature already specified in a previous iteration.
Now that we understand the why’s and wherefores behind Polarion’s adoption of Scrum, the next post in this series will examine how we integrate the various roles and responsibilities, factor in risk, and plan Sprints.
2.1 Roles, Responsibilities and Risks
When implementing a process, you have to decide who fills what roles and which responsibilities are assigned. In real life any organization has hierarchy of management, “important” customers and one or more teams who are to implement defined requirements and deliver products or solutions. Naturally there might be conflicts, which should be clearly identified and resolved.
One such conflict is directives from management: “you have to implement this task in 3 weeks”, for example.
Why do I call it as a conflict? Because it’s actually delegation of a risk to somebody, who doesn’t care too much. My favorite exercise from Ken Schwaber’s Scrum Training – Risk.
Suppose you’ve got a genius idea and you want to implement it. You know that implementation efforts might cost $1million, but you’re sure that this idea is so great that you can return this investment in 1 year. The problem is that you possibly don’t have this $1million so you go and collect the money from all possible sources. Good, availability of the money is ensured, now you’re looking for a team which can do the real work. You spend your time and define requirements – you’re good and you write a50-page Word document, and you feel very confident that the project is feasible.
Now you approach a team and ask them: “Hey guys, I want you to implement this project, here are the requirements, can you do it in 6 months?”. If the team has enough engineers and experienced in particular area, most likely you’ll get answer “Yes, we can. It will cost you $XXX”.
Now we return to my question why I call it a conflict. If the team will implement the project in specified time/money – you’re lucky, there is nothing to discuss. But what happen, if they fail. Who faces what risks here?
The Engineering company you hired, in worst case, will lose some reputation. But you may lose everything – you need to return $1 million and there is no product (or not in time), to give you the chance. Possibly your entire life is broken from this point.
In many situations, directives from management “implement X in time Y” look very similar. Developers are not risking much if they fail with the goal, but the company may face much more dramatic consequences.
Scrum is a framework which gives you a chance to base your decisions or promises on already-collected experience, rather than to place the bet on a one-shot statement.
For example,your development team may tell you “we’re absolutely sure your Requirements document is very detailed and well specifies what we need to do in 6 months, so let us start, we’ll see each other in 6 months for project delivery”. Could that be real? When you think about this question, do you really think are you personally able to specify every requirement for a project lasting several months, and be confident that you haven’t forgotten anything and will not want or need to change/clarify things All of this requires clarification of responsibilities and commitment.
Scrum defines several core Roles:
In Polarion strategically each sprint is focused to equally cover 3 major areas of the application:
- New Feature implementation
- Performance and Usability
Product Owner is responsible to find compromise on how to prepare Product Backlog to cover these areas during the upcoming sprint.
As mentioned, our Iteration length is 2 weeks, which we have thus far found optimal for a team the size of Polarion’s R&D department – i.e. several teams with 3 to 6 team members.
In our development, it’s hard to start with a single Product Backlog, as there are too many stakeholders who want to prioritize their own things first. E.g. there is the Professional Services team, who help customers onsite and who have their own usability wish list (BTW, experience shows that usability requests in Europe are very often different from those in the US – so be careful, when prioritizing :-)). There is also the Support team, which calls attention to common problems, and of course there is Senior Management, who want to see some big features, but they can’t specify exactly what is expected, just a general direction, like “we need XXX Integration, because our competitors also have it”.
So in our environment we have to face the necessity of collaboration with many people from different locations and positions to identify:
- Product Backlog items – these should be described in way that at least the idea behind each one is clear. Therefore we’re using Epics and User Stories, because it’s always easier to describe “I like to have”, than to write a technical specification and get complaints that it’s not absolutely clear.
- Business value for Backlog items – as described above it’s not a single-person decision. Communication and proper means of storing information is required, and consistency about agreements is especially important.
To make it more practical, we did following: the Product Backlog is composed from several other Backlogs – each Backlog has its owner stakeholder. However, anybody in the company is allowed to post new items there. The backlogs contain broad descriptions of all required features and wish-list items. TheProduct Owner’s responsibility is to populate the Product Backlog from those specific backlogs. During the Sprint Planning meeting, the Product Owner discusses the items with the development team. When necessary, Backlog Owners are invited in.
The following picture illustrates process of composing the Product Backlog.
In our case backlogs are mostly populated from the following sources:
- Feature Backlog is populated by Product Management, who collect requests from the Customer Demand list (where PM identifies priority from the customer perspective, business opportunities, and check if a request is customer-specific or popular among several customers),from the Professional Services Organization (PSO), from the Development Team, from Community users and so on.
- Usability Backlog is populated by the Product Management, PSO/sales and Development Team
- Process Backlog reflects requests concerned with how to improve productivity of internal development and provide more transparency to the management – populated by PM and Development Team.
- Performance Backlog is populated by the Development Team based on continuous profiling of the product and reviews of possible architectural refactoring of the product.
- Integrations Backlog is populated by the PSO and Development Team based on input from the customers, potential clients and opportunities for better exposure to or acceptance of Polarion ALM by the customers.
- QA Backlog is focused on testing activities, identification of defects that “must be fixed in next release”, etc.
During the Planning Meeting dependencies between teams are also identified to allow as much parallel work by the teams as possible, keeping the same focus for the iteration.
The planning entity for the sprint is a UserStory. Each UserStory has customer (the person who formulated the requirement) and an owner – typically a Senior Developer, who then follows the User Story through the full ALC.
The second part of the planning meeting is dedicated to splitting the UserStories into concrete Tasks and Improvements. It also helps in the initial steps of creating technical specifications out of the non-technical language descriptions, in the coordination of QA activities, and the provision input to the Documentation team.
Now we’re moving to most sensitive and, of course, most interesting part: how Polarion ALM helps and supports us in applying Scrum practices… the subject of the next article in this series.
Nick Entin is VP for Research & Development at Polarion Software. He oversees the development of all Polarion requirements management, application lifecycle management, and team collaboration software products. He is a member of the Scrum Alliance and a Certified ScrumMaster. You can read his profile at http://www.polarion.com/company/people/index.php.