Design a site like this with
Get started

Frequent management interruptions for developers – A big lean waste in software development

Why do developers disdain to go to regular meetings? Besides, Why managers consistently call for such a variety of meetings everyday?

As a developer, we understand, how tormenting it is to pick your notebooks and go to the conference room for an extensive management meeting amid an occupied busy day.  Particularly when you are profoundly involved in brain-teaser design and development work and desperately need solitary confinement to squeeze your brain cells to get the technical problem solved.

As a manager, we always believe that developing communication structure within and between teams for tenacious, persistent, continuous communication is of significant importance for developing an incredible product. If you are an ‘Agilist‘, you are committed to required daily stand-up meetings, iteration planning meetings, iteration review meetings,  user story pruning meetings, iteration and milestone retrospection meetings. These meetings are important to close the feedback loop between teams, within teams and for an individual developer at different phases of product development. These feedback loops enable and empower continuous improvements in an iterative and incremental development environment. Agile needs regular feedback loops to drive the time-boxed iterations, get the team in a shared mindset and align product development activities with the product plans and milestones.

In a 2 week iteration, if a developer dedicate 15 minute per day on a daily stand-up meeting, 4 hrs for iteration planning meeting, 4 hrs for iteration review and retrospection, 2 hrs for product backlog pruning, It is 15.6 % of the total time(80 hrs) an individual developer has in a 2 week iteration. Investing 15% of you time in an iteration on effective meetings which enable development activities is not that awful for developers. The problem comes, when developers are frequently interrupted in their core hours, during the time when they are deeply engaged in design and development activity. This interruption can be in  the form of unplanned meetings, interviews, cross-cubical talks, manager’s room chit-chat,  unnecessary on demand sink-ups, management updates, group task reviews, and so on..

Development,  particularly coding is a complex activity. It requires collective, cognitive alignment of numerous elements – mental models of problem definition and the environment, understanding of  requirements and acceptance criteria, conceptualized solution options, approaches, design decisions, risks, assumptions, constraints, experiences, influence, understanding of the evolution and emergence of code and design etc. It is a challenge to bring all these elements in-resonance to discover and code the ideal solution. Interruptions, derails the cognitive processing. Interferences, crashes the cognitive transformation of ideas to working code. It makes developer mind to do a context -switch from one problem to another. Problems which are different. Problems which requires different cadence and mindset. When developer returns to development activity, it require them to re-build the mental structure and state. It can be like starting again.

Now, if you are repetitively doing the same kind development activity for a long time and your mind is hard-wired to repeat, you wont’ psyche getting intruded on, and  your manager will love you for being so effectively accessible to him for on-demand dialogs. But, development brings new insight and learning every time you code. Each coding circumstance is different. You have to be alert, investigating, exploring to get the right code artifacts. Yes, even when you are using Google to cut and paste, your mind need to be active to learn and adapt it to your problem needs.

I ponder, why managers require these frequent sink-up meetings with team members. Particularly, if you are doing agile and committed to iteration deliverables. Why do they need to chit-chat regularly with the developers and discuss what you are doing now. Can’t managers join the daily stand-ups and get the status? Don’t manager trust the team’s sprint commitments, skills, knowledge, ability and capacity to deliver on planned work. Particularly, when they are themselves involved in building the team. Shouldn’t the manager spent more time facilitating the iteration review, iteration planning, retrospection meetings, and work on cross-teams communications, competency and skills development, individual’s objective alignment achieve bigger and broader goals?

The bigger question is – What do managers do in agile development?
This is not the topic of this article. I will answer it in another post.

Management and development work require different cadence to achieve its goal. When you are on developer cadence – designing and coding; the daily cadence cycle is longer. I see, 2-5 average non-stop hours required to achieve development tasks. Interruptions during these development core hours break the rhythm of a developer. This context switching can make developers loose the thread and  blow away the entire day for them.

Developer’s and Manager’s work cadence

When your in Test-Driven-Development mode, a management call to discuss status updates can get us out of the context instantly. Here, we just composed a test to express what we intend to code, Interrupted!  we lose the rhythm, the context and the mental-model of it. It takes time to re-build context, to go through the code again, and understand what we were thinking when we actually coded those tests. Everything requires significant re-investment of time and effort- A rework, a big waste. Not to mention the frustration it brings with it.

If you are working on management tasks, cadence cycle is shorter. Managers can switch between tasks within minutes, multi-tasking is accepted and recognized way of doing day to day management work. Management tasks – email updates, co-ordination meetings, status updates, risk assessment and mitigation planning, work facilitation, task planning, resource and capacity assessment etc. all can be composed in of shorter time activities.

Managers need involvement  and participation of development team members to accomplish their work. Since, in most of the projects, managers are in more authoritative and legitimate positions, their call for unplanned short gatherings tend to drastically affect the developer’s development activity.
Manager’s  tend to disrupt  and upset the development activities several times a day. They are unknown of the fact that this regular interruption is causing a context-switch for developers which takes time to reconcile and is prone to loss of information, ideas, approach, problem modeling and solutions. It will reduce the quality of output, lower the productivity, increase re-work, affect the developer’s motivation and commitment and leave them exhausted.

Have you observed the complex behavior of a swarm of ants who have discovered a food source? Disrupt it! What amount of time it takes for the ants to return to the same behavior?

What can be done to bring these two required but distinct behaviors(Managers and Developers) in collective-cadence to achieve the desired shared behavior?

Give some attention to these important points:

  1. Managers should understand and recognize that there are two distinctive types of task schedules in the software development teams  – management tasks and development tasks schedules(which require involved coding and testing).
  2.  Everyone should understand the effect and waste caused by context-switching of development activities.
  3. Managers should learn to avoid frequent interruptions and allocate time for co-ordinated tasks which require involvement of development team members. Like, fixing the meeting timings in the afternoons or sending the meeting request, instead of an on-demand interruption.
  4. Managers should avoid the habit of frequently dropping by the developer’s desk or making calls for on-demand meet-up. Instead, keep a list of required communication and interruption logs and allocate time to do it when the developers are relatively free. Have empathy for developers schedule.
  5. The impact and intensity of waste due to context switching will depend on the type of development(especially coding) work. The more involved and collaborative a development task is, the more will be the waste in context switching.
  6. Developers need to understand the importance of accomplishing the management tasks for the project, and dispense time for it as a team in coordination with managers.
  7.  If the developer feels that interruption and context switching is going to create waste, he should inform the managers and appeal for alternative time to meet. Yes, I understand, many managers will get offended if you request for a change in meeting schedule. They always want it now!  I ask to these managers, isn’t ensuring high productivity, quality and facilitation of uninterrupted development activities your primary goal on the job?
  8. Are you an involved manager? Do you understand and have feel for complex coding exercises? Or Do you think, coding is like any other monotonous task which developer can perform without much attention? Because if you do, then believe me, you are soon going to get the team down. Good developers will leave you to work with better managers.
  9. Listen to your developers, and develop a working schedule for shared activities.
  10. Developer needs to structure their day. Know your schedule, what development tasks you need to accomplish, there complexity and communicate the same to managers.
  11. If developers can’t avoid some interruptions, it is recommended to record their last thoughts before joining the meetings. It will help in resuming the task again.
  12.  Developers can move to meeting rooms when they are working on complex, involved activities which require uninterrupted focus.

Confusion of Employee Performance Appraisal in Agile

Financial year end is near. Your organization has kicked off the yearly employee performance appraisal process. As a manager, what is your situation?
Mr. Sundaram is a confused manager today. He has been working for a Bangalore based software development company called SinsforSystems for last 8 years. He has been asked to provide performance stack-ranking (5, 4..1) for all his reporters, across all grades (E1, E2, .. E5), normalized across 3 teams he is heading, with entire data fitting the Gaussian distribution (The Bell Curve) across all dimensions.
Now, employee performance appraisal is the yearly process in SinsforSystems and Mr. Sundaram has been the champion who has mastered the art of ethical-performance-rating. People have never challenged his judgment and evaluation acumen. He has been transparent and objective in his employee performance ratings. His appraisal practices religiously embraced MBO(Management by Objectives). He is a smart technical manager who sets yearly goals and objectives for each of his subordinates at the start of the financial year and evaluates them sincerely and perfectly at the year end. No exception catching required.  20% of people reporting to him are always top performers, 20% always bottom performers and rest are ‘good performers’.  He is known for successfully giving constructive feedback and setting right directions and goals for those rated as ‘good performers’ to get them into the ranks of ‘top performers’ during next appraisal cycle. Interestingly, during every yearly employee appraisal, he still manages to get his 20% top and 20% bottom ranked employees.  The genius he is, it takes him just 1 hour to complete all the employee ranking papers, without missing the Big boss episode. He has always been an involved manager!

But, this year performance appraisals are a lot different. SinsforSystems has ventured into an agile transition program and Mr. Sundaram has been lately baptized with holy agile water.  He has attended few agile courses, conferences and organized classes. He has been actively engaged in agile ceremonies – Sprint planning, reviews, retrospection, daily scrums. He has been through lessons on self-organization and autonomous team building. He has done some self-reflection on his role in agile teams and worked with agile coaches in team building and agile roles fitment exercises.  

He is not sure if the existing techniques of rating and ranking the team members performance in isolation are going to work this time. He has seen a lot of team member’s involvement, communication has improved, team members are more aware of what is happening in the team, they know who is contributing on what,  and how much. This scrum implementation has bought some noticeable awareness on team visibility, contributions and effective deliverables. Yearly individual objectives and goals they have set do not make sense to him in agile context. E.g. one of the architect’s in the team has a goal of “Creating high quality complete design before development”.  Team is now forced to work on more iterative design and development within the sprint. His goal is somewhat redundant.  Similarly, what is tracked now is sprint deliverables not individual deliverables. He can only give limited credits to those high-profile-experts in the team, who in the past, were recognized for quick completion of tasks irrespective of whether anything makes into the sprint’s potentially deliverable completion list or not. He sees the importance of measuring knowledge building and sharing, mutual trust and team work, re-work, continuous improvement through retrospection, code quality, adherence to agile principles, practices and disciplines, but he does not know how he can change these yearly performance goals for every individual to reflect these much required changes. Does he really need these individual goals now or does he need few team goals in addition?  How will he measure them? Does he a need 360 degree feedback from team?

Mr. Sundaram is sure it’s a different appraisal this year. But, he cannot do much. Human resource department has never been part of the organization agile initiative. They do not know how agile initiatives impact employee’s yearly appraisals, they never planned or modeled for it.

What will Sundaram do?

Do not get lost in agile ceremonies – Create continuous improvement teams and communities in parallel

Agile programs in organization start either in public or stealth mode.  They are either, all-teams-together or pilot-team-only agile programs. ‘Public agile initiative’ has team or organization announcing its agile initiative with a big organization wide fanfare. Stealth mode programs are executed with limited or no noise, with one or more specifically identified teams. Agile programs can also vary depending on the number and intensity with which different agile practices are adopted. Some agile programs may start with few agile practices, others may prefer wholesale process adoption for experiencing the synergy of practices done together. If the public-mode agile initiative is started as an enterprise scale program, the pressure of getting agile transition successful mounts on the stakeholders – the risks and impacts are higher for enterprise level transitions.

Agile programs start with adoption of few commonly known practices by teams. Scrum adoption will start with user stories backlog creation, sprint planning, user stories acceptance review, daily stand-ups, retrospection etc. Teams will receive their first few training lessons from agile coaches or practitioners; who will train them to get these practices adopted immediately. It is important to follow these practices consistently on each sprint because they provide the needed structure for iterative and incremental development. They are important for tracking, communicating and executing in agile iterations. They are our agile ceremonies!

Agile stakeholders, with short and limited vision, soon get lost in agile ceremonies. They think that the agile transition job is done, and results will follow once these practices are adopted. In reality, it’s just the beginning of an agile journey. Inexperienced leaders and managers review and enforce on-time execution of these celebrated events. The issue scope, time and speed control directives – ‘Sprint planning should be complete by Monday first half’ ,  “We would like to see all retrospection done by  Friday morning before the end-of-sprint”,  “How many story points got completed compared to other teams”,  “Can we increase number of user stories getting started or accepted in a sprint?”. They think, only work required to complete the agile transition is operationalizing these activities consistently without any failures.

Well, when we focus too much on these ceremonies and start using incorrect measures to judge the progress of agile initiative, soon the system gets skewed to reinforce activities which are not in interest of agile improvements. Management rejoices; they see their success in implementing practices as-planned. They are getting their reports on time; they know what is planned for each sprint deliverables, and who is working on what. They can hold the team responsible for not delivering on the planned items for each sprint, and they can do it more often in agile.

My advice to agile stakeholders is — ‘ground yourself’. You have just launched an agile rocket in space; you have big tasks ahead to get it into a right orbit, and then drive it into an unknown but continuously improving territory to reap real benefits endlessly. Agile leads need to initiate continuous improvements in practices, technology, tools, values, principles, competencies, collaboration, communication etc. within teams to drive agile efforts to next level.

Following are some of the questions agile leads can ask (in no specific order) to trigger continuous improvements within teams:

  1. What is the commitment level of team for agile (scrum)? Do they just comply or commit to agile? 
  2.  Have all teams adopted scrum?
  3. How teams feel about agile initiative and different way of working? Do they have objections or resistance to scrum? Have we provided teams the open environment to voice these objections?
  4. Do team member understand and embrace agile values and principle?
  5. What has improved? What is the improvement in quality, productivity, predictability and cycle time?
  6. Are scrum teams self-organized? 
  7. Is your product owner involved? 
  8. What is the status on emergent agile simple design, test automation and continuous integration?
  9. What are the continuous integration challenges?
  10. Are you  practicing more matured agile practices like Test-driven-development and Behavior-driven development? Are these XP development practices yielding noticeable results?
  11. Are your scrum masters trained? What other training are needed for the team?
  12. What is expertise of the team in user story driven development?
  13. Do you have a checklist for “Done-Done of user story” and “Ready-Ready for user story”?
  14. Has the code and design quality improved? How we can improve it – TDD, refactoring, reviews?
  15. Do your teams know how to create iterative, emergent design or you still do big-design-upfront within sprint?
  16. Are sprint retrospection leading to improvements? 
  17. What needs to be changed in your values, principles and culture for better agile adoption and continuous improvements? 
  18.  Do we need different measure for agile? 
  19. What are the impacts on external teams (facility, HR)? 
  20. What needs to be done to improve communication and knowledge sharing? 
  21. Are your practices supporting agile values?
  22. What are the challenges of distributed teams? Are we able to scale scrum?
  23. What are the wastes in our agile development and how we are eliminating them?
  24. Are we always working on most important items?
  25. Are we able to complete testing within each sprint? 
  26. Are we able to handle sprint interrupts?
  27. Are the teams adequately staffed with right skills sets?
  28. How are code reviews done? 
  29. What is the expertise level for each adopted practices?
  30. Are we using right tools for the agile practices?
Initiate continuous improvement programs to improve the agile journey. Identify, plan and solve problems which are hindering agility. Create a recognized ‘agile transition committee’ (ATC) responsible for identifying, creating, managing and supporting the improvement plan. This can be a team of key stakeholders responsible for agile transition with agile coaches, experts and enthusiasts.  The primary function of this team is to create a backlog(like a scrum product backlog) of actionable, improvement items, ensure that they are allocated for actions and all necessary support, resources, and guidance is provided.
ATC can facilitate creation of ‘Continuous improvement task teams’ (CITT) to work on specific improvement items. They can be full-time or part-time teams. CITT can be a formal or voluntary team. Voluntary teams have an advantage of commitment. They can build communities around the improvement items to re-enforce and build expertise for continuous improvements. They are committed to addressing cross-cutting concerns. CITT can also be one of the existing scrum teams including the tasks of improvement plan in their iteration backlog.

CITT can target one improvement at a time and research, observe, model, implement, promote and transfer that across scrum teams. CITT can run their scrums to work on a continuous improvement backlog items. ATC team should facilitate overall improvement program and prioritize the improvements for value added results.

Continuous improvement is the engine on which the agile initiative survives and grows. It’s the heart of agile. Without continuous improvement, the agile efforts will not succeed. Organization gravity will kill stagnant agile initiatives.

ATC team will work like a scrum team with an agile improvement backlog; delivering improvements every iteration. They will also act as a product owner for ensuring improvement backlog is prioritized, groomed and ready to be consumed by CITT.

Create and manage continuous improvements teams and communities within organization to fuel your agile initiatives.

Get Started on Test-Driven Development!

Test-Driven Development (TDD) has been a proven and powerful design and development techniques to create high quality product in agile environment. Agile teams embracing TDD thought-process to design and implement their product features have realized significant improvements in code and design quality. TDD increases reliability in software development. TDD driven teams are more likely to meet their User story Done-Done criteria’s for a sprint. They will be able to reduce re-work waste while development, and maintain the flow during iteration. TDD development is always guided and supported by tests. Above all, TDD approach leads to beautiful code – testable, maintainable, extendable and readable.

Following are some experiences (with limited explanation) of TDD practicing agile teams:

 1. Improved Code Quality 

  • TDD helps in creating code that flows better; code that’s easier to understand and use; code that expresses what it does and why, instead of how it does it.
  • TDD driven code is clean and lean. Minimal code with optimum design gets written when team develop TDD way.
  • TDD ensures high quality maintainable code. Well maintained code leads to low re-work and less efforts when extensions and modifications are required on exiting code.
  • TDD produces testable code by making the code cleaner, simpler and less complicated.  Production code is always testable because it is written in confirmation with the test code.
  • TDD improves the readability of the code. Developers continuously re-factor the code to make it more readable.
  • TDD reduces programming errors. Since the code is continuously tested, programming errors are reduced.
  • TDD helps us write thoroughly tested code, and evolve our code with the best incremental design possible at each stage. Test written before the code helps developer to experiment and evolve the code in right direction with controlled quality.
  • TDD helps in avoiding production code explosion. Unnecessary redundant production code does not get written. We build the simplest thing that is needed now and discourage speculative development.
  • TDD leads to testable, maintainable test code along with production code. TDD drives continuous re-factoring of test code along with production code, which leads to high quality, low maintenance test code.

  2. Emergent Design and Architecture

  • TDD leads to good emergent design. It helps developer to think about the code from the perspective of other (existing and non-exiting) code that will use it. It promotes emergent incremental design. Design emerges as production code is written in incremental steps, guided and experimented with tests.
  • TDD guides development to right design and functionality  Developers can avoid coding big requirement and design at one go. Requirements and design gets translated incrementally into well behaved code. 
  • TDD discourages “Big Design Upfront”(BDUF).  It gives opportunities to do design changes incrementally, while developer codes the feature.
  • TDD simplifies the components and object design by simplification of association and relationship consideration between objects.
  • TDD helps in avoiding over-engineering of system design. Short feedback test loops reduce the traditional  bulk implementation approach.
  • TDD provides continuous feedback to drive improved implementation of design with executable tests.
  • TDD design is usable and always testable.
  • TDD enables creation of short composed and cohesive methods and classes.  Composed methods are short and easy to test-methods which perform one single  identifiable task.

 3.  Agile Testing with Quality Test Code

  • With TDD, tests “Do get” written. No postponements.
  • TDD helps in building a suite of repeatable regression tests as we develop the product code. Regression testing time is reduced significantly with well-designed tests.
  • TDD leads to high and effective code coverage for unit tests.
  • TDD coded tests become requirement specification documents – ‘Test as Specifications’. Test serves as documentation for understanding the implemented product features.
  • In TDD enabled environment, there are no unit test explosion. Unnecessary redundant unit test don’t get written.
  • TDD helps in ‘testing the test’ to ensure effective unit tests are getting developed.
  • Unit test written with TDD approach are well re-factored and maintainable.
  • Tests written through TDD will have fewer bugs.
  • TDD drives implementation of design with executable tests.
  • TDD tests are simple and focused on required and essential functionalities only.

 4. Agile Software Development Practices Improvements

  • TDD enables “Programming by Intention“. It makes the developers intention clear by focusing on the actual requirements.
  • TDD enables iterative, incremental and reflective development and testing with short development cycle – feature by feature.
  • TDD helps us write better software faster.
  • TDD leads to test infection – development becomes test infected.
  • With TDD, user stories acceptance gets coded before the actual implementation. It helps in creating executable test suite and leads to “Test as Specification”.
  • TDD increases collaboration with Product owners. TDD developer is quickly able to test different viable options providing early feedback to product owners on the user stories. It will lead to better and more complete acceptance criteria’s for user stories. 
  • TDD get the User stories closer to definition of “Done-Done” by ensuring all acceptance test cases have been coded and have existence in executable form.
  • Code re-factoring is not left for the end. It is done as part of development.
  • TDD enables continuous collaborations between developers. Developers develop empathy for other developer’s code in the team. They tend to collaborate early to clarify the integration and dependency needs.

5. Creative, Thoughtful and Fearless Developers 

  • TDD enables developers to experiment with design and implementation options by continuously simplifying code and design changes. Developers can make quick changes while developing the code; they can test it in parallel, and gauge the required feasibility of design and code. Tests acts as safety-net for code experimentation;  enabling developers to be more creative.
  • TDD focuses the developer on acceptance criteria’s of the user story.
  • TDD helps developer to code without fear. Tests provide the safety-net and act as a baseline for improvements. Developers become fearless to experiment and improve the code and design quality.
  • TDD exposes a gap in understanding of the developer about the functionality. Since the code is developed incrementally, guided by tests, requirements gaps are identified and filled quickly.
  • TDD developer does more and better code re-factoring.
  • TDD focuses the developers on the incremental requirements detailing and implementation; avoiding quick, thoughtless code development.
  • TDD limits and guides developer assumptions – Note: assumptions build on assumptions. Assumptions verified through tests helps in better decision making by developer. Design assumptions are only followed when proved by passing tests.
  • TDD simplifies complexity handling for developers. Incremental development approach of TDD helps in simplifying the complexity inherent in large batch development by continuously providing the feedback loop to developers.
  • TDD focuses the developer on what is absolutely needed right-now, then making that tiny piece work, and finally cleaning up any mess she might’ve made while making it work, effectively keeping the code base healthy.
  • TDD leads to increased developer learning and understanding of requirements!
  • TDD developers are more confident and creative in design and implementation.
  • TDD developers are always in control and at fun!

Managing the iteration Flow–Getting Ready-Ready for user stories in an agile iteration

Agile team needs to get their user stories ready for development before they can be picked for implementation in iteration (Sprints of Scrum). Un-groomed, un-prepared stories, prioritized for implementation in iteration, waste development cycles, and diverts team’s focus from the planned iteration activities and tasks.
Agile teamProduct owners(primarily responsible) and development team members, work on user stories grooming in advance, to ensure that by the time the user stories are prioritized for implementation in iteration, they have enough information to be consumed by development team. This early user stories preparation leads to reduced cycle times and smaller queues for user stories’ unblocked tasks. It creates a pull system for user stories to seamlessly flow from start-to-end of an agile iteration without any impediments and delays.
This early preparation of user stories by ‘Product owner’ with the help of other stakeholders (marketing, support and anyone who can help in clarifying the needs and requirements related to user story) and the development team in getting the user stories ready or ‘Ready-Ready’(as they call it in scrum) for implementation.
This paper answers important questions related to getting ‘Ready-Ready for user stories’ before the start of the iteration.

Following questions are answered in this article:
  • What is ‘Definition of Ready’ (DOR) for a user story in agile iterations?
  • Why do we need to be ‘Ready-Ready for a user story’ before agile iterations?  
  • How can we ensure that we are Ready-Ready for user story?
  •  What is the advice to agile teams getting ‘Ready-Ready for user story’?

What is ‘Definition of Ready’ (DOR) for a user story in agile iterations?  

‘Definition of Ready (DOR)’ is a ‘set of agreements’ for shared understanding of user story in a focused agile team. It signifies that the user story is ready, with all conditions satisfied, for implementation in upcoming iteration. User story should be actionable by agile team during the iteration, so that they can be consumed quickly for implementation. They should get Done-Done without impediments.

Why do we need to be ‘Ready-Ready for a user story’ before agile iterations?

Getting ‘Ready-Ready for user story’ has significant impacts on various aspects of   iterative agile development (scrum sprints).

 Following are some categorized impacts of getting ‘Ready-Ready for user story’.
   1. Ready-Ready impacts on building (and discovering) knowledge and a shared-understanding of the user story in agile team for seamless (effortless) implementation in upcoming iteration.
     The Product owner and the implementation team work at different cadences. Their focus, involvement and understanding of a user story are different at different times, i.e. before and during the iteration. Product owner may have more knowledge (not mandatory though) on the user story before the user story is prioritized for iteration, or at the beginning of the iteration. After the user story is part of iteration delivery plan, implementation team will develop more knowledge and understanding of user story, through continuous dialogues and discussions with the product owner. Irrespective of the differences in focus, involvement and understanding of user stories, all team members-product owner and development team, work together on a common goal of achieving a successful iteration and a successful product.
Time-boxed iterations (as in Scrum) are one way to synchronize Product owner and implementation teams different areas of focus; beginning of iteration is where the mental model synching can happen. If we have a set of user stories with clear Definition of Ready’ or Ready-Ready state at the beginning of iteration, it serves as a synchronization point between Product owner and implementation team. It brings everyone on the common platform right at the start of iteration. ‘Well Begun Is Half Done’ – Aristotle.
    Ready-Ready helps the team to focus on value-added discussions on the problem to be solved. It removes all unwanted, non-value adding activities around  the user story discussions and elaborations.
     Ready-Ready for user story helps in clarifying the basic acceptance criteria’s for the user story. Implementation teams will have solid foundations to conduct right contextual dialogues for elaboration of user story during the iteration.
       2.  Ready-Ready impacts on iteration flow.
     Ready-Ready for user story helps in creating a flow in iteration. It helps in reducing the waiting queues at the start of implementation; it reduces the cycle time of user stories implementation; and creates a pull system where the user stories are quickly pulled, designed, developed, tested and delivered in a iteration., i.e. taking them from Ready-Ready to Done-Done state quickly.  Also, since there is a good shared-understanding of the user story acceptance criteria’s, the design and development tasks related to the user stories can be organized in smaller batches to flow to the next stage (designàdevelopmentàtesting)of development. It enables continuous testing and feedback.
      Ready-Ready for user story let’s everyone in the team know when a user story can be taken into sprint for implementation. It does not need to be “100% accurately defined”, and detailed out with all acceptance criteria; it should have enough details and initial cover-up discussions to get the development started.
      Ready-Ready for user story reduces disruptions and waste caused by context-switching in agile teams— a lean iteration. Since the team are focused, they clearly know the right details of user story. The time spent in basic clarifications, evaluation, and unwanted experimentation is reduced. Note: User stories driven development still requires open conversation in team to succeed.  Remember 3C of User stories – Card, Conversation, and Confirmation.
      Ready-Ready for user story increases the velocity of the team. Since the user stories are already prepared for implementation, team can consume them quickly. It increases the team’s ability to complete more story points and hence increases their iteration velocity.
      Ready-Ready for user story increases the probability of successful iteration (sprint). Team’s chances to deliver the committed items for the iteration increases. It will create wider acceptance of agile programs as the stakeholders will be able to see the results quickly—the working code.
        3. Ready-Ready impacts on the quality of work done.

    Ready-Ready for user story’ reduces the complexity of the user story. Ready-Ready requires story to be small enough to be completed in iteration. Small stories are less complex and better understood by implementation team. They can be implemented without any impediments with better quality.

    Well groomed user stories encourage insightful dialogues, good discussions, more participations, clear acceptance criteria’s and shared-knowledge. All these, contribute to the quality of the iteration deliverable.

    Ready-Ready for user story helps in minimizing the re-work, and maximizing creativity, and quality of deliverables.

        4. Ready impacts on the agile team’s motivation and commitments.
      Ready-Ready for user story increases the commitment and confidence of the team for accepted and committed work during the iteration. It eliminates all unknowns that hinder the right implementation of user stories; increasing the confidence level in the agile team. Of course, when we are clear on what has to be done, we show more confidence to complete it.
      Ready-Ready for user story helps the ‘Product owner’ to gain confidence of the implementation team. She feels ‘involved’ right at the start of iteration which further helps in building an environment of open dialogues and conversation between team members.
      Ready-Ready for user story will have impacts on the morale and motivation of the team. Team will have more control on the delivery of the committed work. It will increase the self-organization capabilities of the team; it will develop trust in stakeholders for the agile team; it will facilitate teamwork; and it will increase the collaboration between the implementation team and the product owner. 

         How can we ensure that we are Ready-Ready for user story?

Ready-Ready for user stories can be presented as guidelines or checklist for agile iterations. It depends on the team and how they want to incorporate it. Agile teams should remember that the Ready-Ready for user story is an evolving phenomenon. There is no fixed check-list which can be used. It will change based on the context of iteration. There will be some basic guidelines (checklist items) which will be common across all Ready-Ready user stories preparations.

They can be classified in following two 2 categories:

  1.  Common ‘Ready-Ready for user story’ guidelines and checklist: They will be common across all types of use stories
  2. Context specific guidelines for ‘Ready-Ready for user story’: This will depend on the type of user stories we are developing in iteration. E.g. User stories around user interface development will have ‘UI mock-ups or wire frames’ in the Ready-ready list or required architecture guidelines and diagrams.
    We discuss some Common ‘Ready-Ready for user story’ guidelines here.

Checklist for assessing the readiness for ‘Ready-Ready for user story’

(In no specific order)      


‘Ready-Ready for user stories’ check


Are we doing it? Yes/No


Is the user story well defined?

The Actor (Who is doing the action. ‘AS A’), The Action (work done, ‘I WANT’) and Purpose (value addition in performing the action, ‘SO THAT’) should be clearly conveyed in the user story.

User story template – ‘‘AS A’ I WANT SO THAT ”.



Do the user story follow the INVEST model?


The INVEST model for user story:
Independent: The story stands alone with no dependencies.
Negotiable: Story should act as a starting point of conversation during the iteration. This conversation between team members will result in details about the implemented functionality and the acceptance criteria.
Valuable: It should demonstrate some well understood value to end customer.
Estimable: Known story points for the user story to be completed within iteration.
Small:  A story should not take longer than a sprint to finish 
Testable: It should be easy to define and test the acceptance criteria’s. 



Are we confident about the value and intent of the user story?


Does everyone agree on the viability and usefulness of the user story?  

Which means everyone agrees that user story is important for the product and should be immediately implemented to meet the product goals.



Are all known basic user story acceptance criteria defined?


It does not need to be all acceptance criteria’s upfront. Most of them will be discovered when conversation on user story happens during the iteration. Basic expected behaviour of the user story should be clearly understood, and communicated.



Are all dependencies of user story identified?


Tight coupling between the user stories make them difficult for prioritization and estimation. User stories can be split into two or smaller user stories or they can be combined together to be completed in single iteration to reduce the dependencies and its impacts on the readiness of the user story for iteration.
e.g., Do we need to complete some other tasks before picking this user story? Do we need to wait for availability of some items (code, components, design etc.) from other teams?
Have the dependencies among different user stories in the backlog sorted out? etc.



Is the user story sized and estimable by team? 


The early estimation of the user story is possible if we know the following:
Do I have a realistic knowledge on how long it is going to take to build the user story?  It won’t be right, but it needs to be a reasonable estimate given all that I know. 
Do we know at a fairly high level about the tasks to be done to complete the user story?
Do we know the story points (measure for user story) required for the user story? 
Do we know our velocity (capacity and speed at which we can complete story points) for iteration?
Do we need to merge or split the user story into more granular stories for better estimation? User story should be short enough to be implemented in single iteration. Otherwise it needs to be split into two or more user stories.



Have we identified the owner; the person who will accept the user story after it is completed in iteration?

This has to be the product owner in most of the cases. Except for technical user stories owned by engineering team.
e.g. Development of a product infrastructure component. 



Have we given some thoughts on how the user story will be implemented? 

Do we need (or have) higher level solution design for the user story?   
e.g. early UML class and sequence diagrams, or just white board sketches can help in knowing how the pieces work together.




Have we identified all implementation impacts of user story? 


1. Are there any critical design or architecture changes? 
2. Are there any impacts on the implemented code?  
3. Do we need any refactoring of existing code?
4. Are there any code flow change? If yes, do we know, how will we validate the code flow or any behavioural changes?



Has the implementation team accepted the User Experience (UX) artefacts (if any)?


Basic Wireframes or UI mock-ups should be available.



Do we have good idea on what it will take to demo the user story?


Understanding of, what it will take to demonstrate a user story will give team an insight into the user story integration and deployment requirements. It can uncover unknown constraints for user story implementation and acceptance.




Has product owner committed and signed for the user story? 


Product owner commitment is important for acceptance of user story.



Do we have our development environment ready for user story? 


Any specific server, package, library etc. required?



Do we know all the required non-functional requirements (Quality concerns: performance, scalability, availability testability, etc.) which will be affected by this user story?  


Non-functional requirements (NFR) are cross cutting concerns spanning across multiple user stories implementations. User stories implementations should address these NFRs (or product quality concerns). The components created, and their implemented functionalities should positively enable required quality concerns. Create a matrix for NFR vs. components or classes created, modified and impacted by user story. Some early understanding of these NFRs, helps in reducing the design and development time of user story. It also helps in reducing any later re-work that is done to address these quality concerns. Build the NFR into the user story design and implementation.



Can we implement this story in iteration?

Do we need to break the story into two or more stories?

Do we need to apply some constraints to the user story?


User story should be a single iteration consumable unit. Large user stories are complex and difficult to understand, debate, implement and test. Keep it small and manageable.

User stories may have dependencies on other pending user stories, availability of external libraries or API’s etc.
Knowledge of Non-functional requirements like performance, interoperability, robustness, availability etc. will also constrain and impact the readiness of the user story.



Are we making any assumptions related to user stories?


State all assumptions related to user story. Assumptions can arise due to solution boundaries or due to lack of information.



Do we have clear and shared-understanding of product and design principles and goals in context of user story?


Prioritized Product and Design principles will help the team on the following:
        1) To help in making right design trade-off decisions. They serve as clear statements of what the team believe and agree on the purpose of product and design.   
        2) They help in setting right stage for constructive debate, and arguments within team about the user story.
         3) They create visibility and clarity in decision making, and reasoning during the user story conversation.
Product principles:  Product principles guide the user story purpose. They are foundation for user story elaboration discussions; that take place in the team between developers and product owners. They bring together the product owner and implementation team on common platform. Product principles should be prioritized for clear understanding, and use in product decision making.  E.g. What is more important for current release? – High usability or increased scalability to handle rapid user additions with acceptable and simple usability. 
Design principles: Design principles guide the design and architecture strategy. They help in making important design trade-offs. T
Together, the clear and shared product and design principles can really ensure a smooth start of iteration. It will resolve design conflicts, help in design and implementation feasibility assessment, and quick user story acceptance and development. It helps in ensuring effective process for making early, informed, product and design decisions in iteration.

e.g.  Do we need to open our API’s for user access?

This will depend on out product strategy, which, if yes, will influence the user story design and time lines. It is good to know these details in advance.



Are there any requirements for specific technical skills and knowledge? 

External expertise like UI design experts, database expert etc.




What is the advice to agile teams getting ‘Ready-Ready for user story’?

Ready-Ready for user story’ definition will evolve. There are no specific template guidelines or checklist for ‘Ready-Ready for user story’. Depending on the context of the product, teams (skills, knowledge, involvement etc.), and type of user stories in iteration, these guidelines will evolve. Idea is to continuously brainstorm and retrospect during iteration, to create a dynamic, evolving list of ‘Ready-Ready user story’ guidelines. Include, what works, and makes the task of implementation of user story easy; exclude others non-value adding, squandering activities. The Ready-Ready checklist is a living document and should be kept up-to date with iteration feedback.
Getting ‘’Ready-Ready for user story’ is everyone’s responsibility. Though product owner is primarily responsible for getting the prioritized product-backlog user stories ready before iteration; it requires everyone’s involvements. At least, the key stake holders from the development team should be part of the process. Scrum Master, Business Analyst, team members, and anyone, who can be pulled to get the required user story details, should participate. Cross-functional agile teams should be responsible for creation, assessment, agreement and adherence to Ready-Ready.
Specific elements of ‘Ready-Ready for user story’ will likely be different for every team and project but there will be common elements across these scenarios. Once successfully implemented in one team, the concepts and knowledge acquired can be transferred and replicated to product iterations.
Iteration retrospection is a great source of feedback on ‘Ready-Ready for user story’. Ensure that Ready-Ready issues, and required improvements, are discussed during iteration retrospection meetings. Prepare to incorporate suggestions on Ready-Ready immediately in next iteration. Note: Ready-Ready creation is an evolving process.
Product owner should commit to Ready-ready. Product owners should take a lead in defining the Ready-Ready for user story criteria’s. Product owners’ full involvement and commitment is necessary for its success. Getting to the state of Ready-Ready for user story will require preparation from product owner before the user story is considered for iteration. Product owner should continuously refine, prune and groom the prioritized user stories in the product backlog before they become part of the iteration (sprint) backlog. Some upfront discussions before the start of iteration will ensure acceptance of desirability (what is needed?), viability (value addition), feasibility (implementation and experimentation) of user story for agile implementation team
Product owners should groom the epics and use stories in the product backlog in advance. Usually, having product grooming cycles half or one iteration in advance, before the user story is actually prioritized for the iteration is a good idea. Recent retrospections on Ready-Ready inputs are valuable and they can be incorporated quickly for Ready-Ready improvements. Doing it ‘too early’ or ‘too late’ will create issues. Doing it ‘too early’ will miss the retrospection inputs. Doing it ‘too late’, will not leave enough time with the team to uncover and unblock the unknown risks associated with the user story. It will still require some upfront planning from the implementation team to discuss (with product owner), and get the user story in Ready-Ready state.
Only Ready-Ready user stories should be scheduled for iterations. Scrum master should ensure that only Ready-Ready user stories are scheduled for implementation in iteration.
Getting Ready-Ready for user story should be a planned activity. Scrum master should dedicate time during iteration to participate in grooming exercise for getting the prioritized user stories Ready-Ready for next iteration.  As discussed, the goal of preparing the user stories for the next sprint and allocating time for it will increase the overall flow during future iterations.

MindMap files

 1) FreeMind mind map files( format) are available for download. ->Click here.

 2) Click the image below to get the jpeg for mind map(best viewed in Chrome browser with zoom).

Ready-Ready for user story

Scott Ambler on Agile Architecture

I have been doing some research on agile architectures. I am also writing an article on the same. I recommend the following article from Scott Ambler for everyone trying understand the architecture creation and evolution in agile world.

 Agile Architecture: Strategies for Scaling Agile Development

Done-Done Checklist for “User Story” and “End of Iteration” in Scrum – Mind Map Diagrams

Why we need agreement on Definition of Done”(Done-Done) in Agile development with Scrum?
Primary purpose of agile project is to deliver value at the end of each sprint and release.  Agile teams’ members should have common shared understanding of  What is a quality deliverable ?
“Definition of Done” for iteration, releases and for every user story or feature makes that shared understanding clear and measurable to all team members.  On papers, it is an audit checklist which drives the quality completion of a agile activity.  The entire process of creating, maintaining, reviewing, updating and making the required process, practice and technology changes in agile team to enable Done-Done helps in establishing right standards and benchmarks for continuous improvements.
I have created a Mind map for listing the “Done-Done” items for User story and End of iteration.  Agile team will brainstorm, identify, evaluate and create their Done-Done checklist. This is to help and guide the team in the process.

Done-Done for ‘User Story’ Mind Map

Done Done for User Story Mind Map


Done-Done for ‘End of Iteration’ (Sprint) Mind Map

Done Done for Iteration Mind Map

Done-Done for User Story or Feature Checklist Points

Code Complete
    1. Code integration and merging complete.
    2. Required code refactoring done
    3. Coding, architectural and design  standard \ guidelines met
    4. Design agreed – Design and code reviews done and recorded for implementation and test code. Identified code changes complete
    5. Javadoc for classes and functions complete
    6. Design complete and optimally documented
    7. Unit test written and successfully executed
    8. Code is merged with current version of code repository and checked  with appropriate comments after successful test runs
    9. All Story points addressing functional and Non-functional requirements addressed.
    10. Static code analysis complete. Issues fixed.
    11. All //TODO marked items in code are completed
    12. All known bugs related to user story fixed 
Test Complete
    1. Automated unit and integration tests written and run successfully
    2. All acceptance criteria identified, conversed and discussed collectively, written and tested successfully
    3. Integration test created and executed
    4. Performance testing need identified. Executed (if possible)
    5. Functional testing by QA ( other than the developer ) has been done
    6. Non-functional (performance, reliability, scalability) tests related to user story(or in integration with other user stories) identified and executed.
    7. Pending known defects(due to dependencies etc..) discussed and agreed for action
    8. Code coverage achieved by the automated tests is measured and analysed against the accepted figures
    9. All acceptance tests for user story listed, discussed and tested
    10. All known bugs related to user story  tested.
Approved by Product Owner
    1. All User acceptance testing results approved
    2. Product backlog updated with the completed user story
    3. Product backlog updated with new identified user stories or changed and agreed priorities
Other User Story Done Agreements
1.   Required documentation related to user story is complete
2.   Build and deployment scripts and related configuration files have been updated
3.   Architecture and Design doc \ wiki updated
4.   All team conversations related to User story complete. Agreement from team achieved
5.   All impacts related other pending user stories identified. New priorities (if any) identified and recorded 

Done-Done for Iteration (Sprint) Checklist Points

All User Stories\feature Code Complete
1.      Code integration and merging complete.
2.      Required code refactoring done.
3.      Coding, architectural and design standard \ guidelines met.
4.      Design agreed – Design and code reviews done and recorded for implementation and test code. Identified code changes complete .
5.      Javadoc for classes and functions complete
6.      Design for all user stories complete.
7.      Unit test written and successfully executed.
8.      Code is merged with current version of code repository and checked with appropriate comments after test runs.
9.      All Story points addressing functional and Non-functional requirements addressed.
10.  Static code analysis complete. Issues fixed.
11.  All //TODO items in code are completed.
12.  Code is deployment-ready. This means environment-specific settings are extracted from the code base.
13.  All known bugs for the user stories fixed.
Test Complete for all Users Stories and other Iteration items 
1.      Automated unit and integration test written and run successfully for all iteration items.
2.      All Acceptance criteria’s identified, conversed and discussed collectively, Written and tested successfully.
3.      Integration test created and executed.
4.      Deployed to system test environment and passed system tests
5.      Non-functional (performance, reliability, scalability etc..) tests related to user stories( in integration with other user stories) identified and executed.
6.      Functional testing by QA (other than the developer) has been done.
7.      Pending known defects (due to dependencies etc..) discussed and agreed for action.
8.      Code coverage achieved by the automated tests is measured and analyzed against the accepted numbers.
9.      All acceptance tests for user story listed, discussed and tested
10.  Compliance with standards (if any) verified.
11.  All known bugs tested.
12.  Build deployment and testing in staging environment complete.
Design and Architecture Reviews
    1. Architecture and Design enhancements discussed.
    2. Architecture and Design decisions documented.
    3. Stakeholders (Developers, Product Owners, and Architects etc) communicated about the updates.
    4. Impacts of Architecture and Design updates on other user stories identified and recorded.

Sprint Retrospection Complete
    1. Sprint retrospection meeting complete.
    2. Progress on last retrospection actions reviewed.
    3. Definition of Done-Done reviewed. Updates (if any) done.
    4. Action plan created out of retrospected items. Responsibilities owned.
    1. Code coverage reports available.
    2. Required Documentation related to all user stories is complete.
    3. Product backlog updated.
    4. Code reviews records available.
    5. Release notes available.
    6. Architecture and Design documents updated.
    7. Documentation change requests for pending items filed and fixed(if Documentation team member is part of the scrum team).
    8. Project management artifacts reviewed and updated.
    1. Sprint items ready for demonstrations.
    2. Sprint demonstrations for all user stories conducted for stakeholders.
    3. Feedback reviewed and recorded for planned actions – Enhancement change requests or Bugs filed.
    4. Stakeholder (Product Owner in particular) explicitly Signs-Off the Demonstration.
Build and Packaging 
    1. Build scripts and packaging changes fixed, versioned, communicated, implemented, tested and documented.
    2. Build through Continuous integration – Automated build, testing and deployment.
    3. Build release notes available.
    4. Code change log report has been generated from code repository.
Product Owner Tasks
    1. User Acceptance tests passed for all user stories. Accepted by Product owner.
    2. Product backlog updated with the all completed user stories.
    3. Newly identified user stories or other Technical debts items updated in the product backlog.

             Other Tasks Complete

    1. All tasks not identified as user stories(Technical Debts)  completed.
    2. IT and Infrastructure updates complete.
    3. Stakeholders communicated about the iteration release details.
    1. All sprint user stories demonstrations reviewed and signed off by product owner.


12 Critical problems with product development

12 Critical problems with product development orthodoxy

1) Failure to correctly qualtify economics
2) Blindness to Queues
3) Worship of Efficiency
4) Hostility to Variability
5) Worship of Conformance
6) Institutionalization of Large batch sizes
7) Underutilization of Cadence
8) Managing timelines instead of Queues
9) Absence of WIP constraints
10) Inflexibility
11) Noneconimic flow control
12) Centralized control

Excerpt from Donald Reinertsen’s  book – Principles of Product Development Flow
Good book to understand  why and how lean and agile principles solve product development problems