Interesting… DoD is defined by the development organization

All along I thought it was supposed to be defined by the Scrum team — with the development team and the Product Owner aligning on the Definition of Done. That’s how we’ve done it in the past projects I’ve had. But then I’ve come across a material saying otherwise. Apparently, based on the 2017 Scrum Guide:

…If the definition of “Done” for an increment is part of the conventions, standards or guidelines of the development organization, all Scrum Teams must follow it as a minimum.

If “Done” for an increment is not a convention of the development organization, the Development Team of the Scrum Team must define a definition of “Done” appropriate for the product. If there are multiple Scrum Teams working on the system or product release, the Development Teams on all the Scrum Teams must mutually define the definition of “Done”.

To be fair though, there was no convention that we knew of or that we were advised to adopt. And so the Scrum Team went ahead to define “Done” (which apparently is more consistent with the 2020 version).

My past projects happened to be consistent around our DoDs. Unless there’s some exception which then had to be documented in the acceptance criteria, to be considered “Done”, user stories generally were…

• dev tested
• peer reviewed
• deployed in the test environment (via automated scripts)
• tested by testers in the test environment, with all major to critical bugs resolved
• reviewed by the BA in the test environment
• reviewed and accepted by the PO in the test environment

Looking into the 2020 Scrum Guide, it seems they changed it such that if there’s no such organizational DoD, it’s the Scrum Team rather than the Development Team (as in the 2017 version) who defines it.

If the Definition of Done for an increment is part of the standards of the organization, all Scrum Teams must follow it as a minimum. If it is not an organizational standard, the Scrum Team must create a Definition of Done appropriate for the product.

The Developers are required to conform to the Definition of Done. If there are multiple Scrum Teams working together on a product, they must mutually define and comply with the same Definition of Done.

Tech lead thinks it’s ok to skip Sprint Planning

I heard about a Scrum Master asking the Tech Lead to provide a heads up in advance in case he won’t be able to attend their meetings (in this case, it was their Sprint Planning). The Tech Lead said that his absence shouldn’t affect the Sprint Planning since the team would just be doing estimations (deduced meaning because the original reason he gave out didn’t make so much sense).

True that his absence shouldn’t keep the Sprint Planning from happening. But the Sprint Planning is not just about estimations. More than anything, it’s about alignment.

So what happens in a Sprint Planning? At least from my experience (affirmed by and sprinkled with some stuff I read about from Kniberg):

• The team goes over the potential sprint backlog items from the Product Owner — sizing and discussing the stories, breaking them down further if needed, adjusting the prioritization if needed.
• The team brings up any other technical user stories that need to be prioritized.
• The team / Scrum Master brings up any user stories or improvement items from the retrospective that needs to be prioritized.
• The team gets informed of any critical dates or targets that they should be mindful of in the sprint.
• The team agrees on the following:
  • Sprint Goal
  • Sprint Backlog (defined as not just the list of stories, but also including a “plan for delivering the product Increment and realizing the Sprint Goal.”)
• The team aligns on their availability (e.g., planned leaves, out of office dates for training, etc.)

So there. To me what’s essential about the Sprint Planning is starting off the sprint at the right foot with the team being in the same page. Ideally, it’s coming out of that meeting not feeling defeated (oh, no, we’re dead, we have an impossible deadline) but rather feeling united and empowered (we can do this).

Retrospection and learning time

Just recently, my engagement to my project since Nov of last year has ramped down. So the past couple of weeks has been a time of transition for me into my upcoming project and also from me to the new PO of my previous project. This allowed an opportunity for retrospection, and also a chance to pick up on new stuff.

While looking up the available knowledge sharing platforms within the company, I came across the option to host stuff in our enterprise GitHub instance. One link led to another, and I came across…

• MkDocs – This is for project documentation; it allows the use of Markdown for writing content, and then you generate static site contents from that.
• Documentation as Code (docs-as-code) – While I’m not a programmer, getting familiar with the concept wouldn’t hurt. And as I read more, it’s not really exclusive to programmers.
• Diagrams as Code with Mermaid – Part of the family of stuff-as-code, this doesn’t trail far behind. I think what I find promising about this (apart from being free) is that this is going make comparison of versions easier since you’re comparing text files.

As mentioned, I did some retrospection. I collated some of my personal lessons learned and posted it in our project’s Confluence page. I also revisited Software Development’s Classic Mistakes. I tried rereading The Scrum Guide and some stuff on anti-patterns to see where we’re somewhat deviating (for guidance if it’s something we should continue or if we should “realign”). Then I tried to pull out project-agnostic stuff that could be helpful to me for starting a new Agile Scrum project and collated my notes.

With the notes in hand, I’m starting to use it as a reference for the new project, and I plan to just tweak accordingly as I find other useful stuff to add in. At this stage, there’s already a team working on the prototypes, and in theory, they’re prepping the solution or the design which will be handed over to the implementation team. So I’ll be keen on learning a lot more and looking for process improvements for the handover from Design Thinking to prototyping to implementation. Exciting stuff! 🙂

Notes from webinar: Write Better User Stories…

Last week, I attended a free webinar by Mike Cohn of Better User Stories on the topic of “Write Better User Stories in Less Time With Less Aggravation”. Right after, I shared the replay link to some colleagues along with a few bullet points of pros and cons.

(+) interesting, maayos explanation
(+) ok din yung q&a
(+) insightful naman, gives you something to think about, stuff to google further
(-) promotional, the whole course is expensive $395

Posting my notes here since the learning from the webinar is something worth revisiting.

3 Techniques

1. Conduct a quarterly story-writing workshop
2. Split stories to demonstrate progress even if the result is not truly shippable
3. Strive to add just enough detail, just in time

Technique #1: Conduct a quarterly story-writing workshop

• Deliberate, focused meeting
• Brainstorm the stories needed to achieve the period’s most important goal
• Short-term focus causes teams to give in to what’s urgent over what’s important
• Team able to step away from day to day crisis… Without that big goal, the crisis always wins

Focus on a single objective

• “What shall we build?” — Wrong question, too broad, anything is fair game
• PO selects the significant objective (SO)
• SO typically achievable in about 3 months
• MVP, sometimes overused, seems can only be used once
• MMF = Minimum Marketable Feature = subset of overall feature that delivers value when released independently, smaller than MVP

Involve the whole team in writing stories

• Time investment, pays back on time savings when team works on the user stories
• They’ll have fewer questions later, they’ll have more context
• Fewer interruptions to devs’ day
• Devs may come up with better implementation, increased creativity

Visualize user stories with a story map

• Story maps invented by Jeff Patton
• Each card = 1 user story (1 thing the user needs to do)
• Horizontally = sequence of activities (don’t obsess over combination of sequence at this point, some steps may be optional)
• Vertically = alternatives (with most important on top)

Technique #2: Split stories to demonstrate progress even if the result is not truly shippable

• 90% joke – Ask dev how done are you and he replies 90%. Come back after a week, and answer is still 90%.
• Devs are not evil or liars, Estimating how done we are with something is notoriously difficult.
• In Agile, easier, no need to estimate. Just 2 states = Not started or Done
• 5 techniques for splitting stories (Lookup SPIDR), shared in the webinar were Splitting by Interface and by Rules
• When you split stories remember the goal is to be potentially shippable — (1) high quality, (2) tested, (3) what it does, it does well

Technique #3: Strive to add just enough detail, just in time

• Too much detail, too early vs Too little detail, too late
• Bad habit – want to know all before starting — when they do that they’re not doing overlapping work (analysis first, before coding, testing…). Overlapping work is central tenet in most Agile processes (that’s why we don’t have phases in Agile). Time to market gets stretched.
• Err on the side of too little, too late — you can improve by adding more detail next time
• Question 1 (during refinement or other discussions on a user story): Do you need the answer before you start on that story? Sometimes you need it before you finish work on that story, not before you start.
• Question 2 (during retro): Did we get answers just in time in just enough detail?

Reference / links:

• Webinar Sketchnote
• Mike Cohn’s Better User Stories
• Mike Cohn’s Mountain Goat Software (I think I’ve also linked to blog posts from this site at least once in previous posts)
• Webinar Replay Link (would be unavailable after Jul 30 EST but leaving it here just in case the slight chance they forget to put it down)

Keep the Backlog clean

I just mariekondo’d our backlog. So far, so good, I’ve removed 85 items from the backlog — 53 of which were over 200 days old! My thinking is if we won’t be touching them anytime soon or at all, I want them out of the backlog.

Idk but some lessons to share or possibly reminders to my future self here…

• Get to know your tool – Find out how you can “archive” user stories that you want shelved, and also how you can access the shelved items in the future just in case you need to. Until recently, my options in the tool was limited to either delete or mark as done (which I didn’t want to do for items we won’t actually work on). We then found out that we can do project customization in the tool contrary to what we’ve been initially told, and so I’ve tweaked the workflow to also consider user stories that I want shelved.

• Housekeeping keeps the backlog tool more usable – At some point, it was hard to move things around the backlog because of too many useless items that cluttered the list. Having a lean backlog also makes the items we actually need to work on more visible.

• Maybe it shouldn’t be a list of wishful thinking, or a place for idea dumps – And TIL, using the backlog as a storage of ideas is a Product Backlog Anti-pattern.

• Keep it aligned with the roadmap – Again, (“The product backlog is not reflecting the roadmap.”) another anti-pattern. I guess in conjunction with the previous item, a lot of the user stories that I cleaned up were raw ideas that they had wanted to build “someday”. Keep it real by keeping the backlog items as a list of things the team will actually work on.

• Avoid / minimize duplication – For some reason, if a user story has to be kept duplicated, ensure they are linked to each other. The risk of duplication is in case of refinements, updates might be made on just one of the user stories when in reality you want it to be carried out across all.

• Do periodic cleanups – This clean up is not and should not be a one time thing to keep the backlog relevant. An idea I picked up here is about setting a limit to your Design in Progress (DIP) or the number of items you have in the backlog.

• Be mindful of what you add in the backlog – You don’t want the backlog items to keep growing and growing and revert back to a state you find less desirable. And an idea I picked up here is about setting a limit to your Design in Progress (DIP) or the number of items you have in the backlog.

So there, future me, keep the backlog clean. Keep it useful not only for yourself, but more importantly, for the rest of the team.

One link leads to another

Sometimes I come across posts or material in the internet on topics that piques my interest. It could be something I want to know more or understand more about. Or it could be related to a conversation or two I’ve had within the day that makes me question certain things. So sometimes I google, and sometimes I just stumble upon them through various feeds — could be Twitter, email, Medium, IG, and Facebook even. And then one link leads to another and before I know it, it’s 2AM and I should be getting some sleep. So anyways, here’s a dump of some recent links, in no particular order. I hope someone finds them helpful or interesting as I have.

Agile Product Ownership in a Nutshell (15 minute video) – I like how the content was easy to follow. There were a lot of points worth highlighting, but I guess what hits home the most is the mention of three things that need to be balanced:

• Build the right thing (PO tends to focus here)
• Build the thing right (dev team)
• Build it fast (SM or Agile coach)

So you want to be a Scrum Master (book) – This is a Leanpub book which you can get for free, or not if you can afford to make a payment / contribution. It’s written by an Agile community of interest with the intent of sharing what they’ve learned and what they’ve seen to have worked.

The 3 most effective ways to build trust as a leader (post/article) – Got this from Rob Lambert but I can’t remember where exactly — “Three typical management activities that get poor results and three that get good results”. I’m not really a leader by title but the three ways of building trust that the post enumerates are still relevant to me and they emphasize points that I value: Empathy, clarity of intent, and follow through.

DISC Profile Types (personality test) – This is something I picked up from Rob Lambert’s webinar. For each profile type, there are recommended ways on how to better communicate with them, and inversely there are recommended ways on how to encourage others to better communicate with you. Took the test myself and got 48% Compliance, then Dominance, Steadiness, and lastly Influence.

12 common mistakes made when using Story Points (post/article) – This reminded me of something a colleague had shared wherein their Scrum Master wants them to estimate in hours rather than in story points, and also her thinking that story points can be easily translated to hours.

Agile Makes No Sense (post/article) – Let me just quote some lines (actually last 2 paragraphs) that I liked…

What is the smallest thing that could add value (and make sense)? A better standup? A better retrospective? Inviting a customer to a demo? Pairing for a day? Agreeing to get something into product in a couple days? Try that. Make one thing make sense as in “wow, I can see how that created value”.

When you take this humble approach — instead of “installing” a bunch of artifacts, tools, roles, and rituals AKA doing Agile — I think you’re embracing the true spirit of Agile.

Something to google: Sprint 0

There was an interesting topic while a couple of colleagues and I were on our way to buy coffee. It was triggered by a question about Sprint 0. Based from my limited working experience, Sprint 0 is like an initiation phase wherein the project gets set up. Dev environments get set up. First set of epics and user stories are created. Some initial designs get created. Project team members get on-boarded. Working agreements get defined. Collaboration tools like where to capture user stories and clarifications get finalized. Etc, etc. Basically, the team buys itself some prep time so that they can hit the ground running by the time Sprint 1 comes — ideally, by then, the team could commit to completing user stories and actually have features working at the end of the sprint. But then I thought, we don’t necessarily release anything after Sprint 1, so would calling Sprint 0 “Sprint 1” make any difference?

Idk. Maybe there’s this extremely high expectation about being or switching to Agile that makes it feel like you’re doing it wrong if you don’t have anything visible to some of your stakeholders by the end of a Sprint N. Being part of the development team, I know that infra setup is important, design work is important, all those other prep work are important. I know how 2 weeks could so easily fly by without seeing something that an end-user could potentially see. But to someone outside of the development team who might not be so familiar with Agile, they might have this extreme notion that “Hey, you’ve just completed 2 weeks! Where’s my working software?” And so maybe project teams resort to having a Sprint 0 to “protect” themselves or the concept of Agile to better manage expectations. Idk.

I went out of that conversation thinking that’s something I’d google. Just a few of the interesting stuff I found, and I’m sure I barely scratched the surface:

• Sprint 0 (forum topic) – there’s mention of using Sprint 0 as a crutch
• Scrubbing Sprint Zero – apparently, there’s no official “Sprint 0”; there’s the idea that it’s an anti-pattern; it’s been discussed by Agile Manifesto signatories all way back in 2008. I loved the Alistair Cockburn (often pronounced like “Co-burn”) quote:

I have a sneaking feeling that someone was pressed about his use of Scrum when he did something that had no obvious business value at the start, and he invented “Oh, that was Sprint Zero!” to get the peasants with the pickaxes away from his doorstep.

… and then others thought that was a great answer and started saying it, too. … and then it became part of the culture.

• Sprint Zero: A Good Idea or Not? – there’s mention of the “project before the project”; and it links another post about using scrum for an analysis project whose output is not necessarily immediately working software
• Antipattern of the Month: Sprint Zero – Lol, that quote: “Sprint 0 is like Casper, the friendly ghost. Well-meaning, but creepy.”

And, that’s all she wrote! Time for bed!

How our team “does Agile”

Super quick background: Our project started Jan 2015. To kick things off on the Agile methodology, our Scrum master conducted a brief training (less than half a day) to the team, and we’ve been playing it by ear ever since.

Over the course of many sprints, retros and releases, we’ve made adjustments on how we’re doing Agile. I’m not sure if there are Agile Purists who would frown down and shake their heads at us for the variations we’ve made. But the thing is, despite our possibly non-canon approaches, what still matters most is the team closely working together to deliver working software.

This post might be TL;DR. But in case you’re still interested in having a peek at how our little team does Agile Scrum, go on and have a read…