Reading time ~ 5 minutes
At the beginning of this year the team I’ve been supporting hit a wall. After a deeply troubled project last year they’d started researching a “new” feature in December with a plan to get rolling in January.
After the holiday break, a couple of weeks into January we had a near-mutiny and hit the reset button.
Things are now back on track and working in a radically different way but here’s the story.
Early August – Halfway through a deeply troubled “rewrite” project. One of the paired project managers left and I was asked to support the remaining PM.
Mid August – Working with the remaining PM we visualised the entire scope of the UI on the team’s whiteboard and immediately excluded all dialogs and rarely used parts of the UI from the project. Essentially halving the scope of work
Late August – The second PM moved back to a development role elsewhere and I joined the team full-time. I started digging deeper into the scope and data. After reconciling the stories the team had on the wall with those in the electronic backlog we discovered as much additional scope as had been removed 2 weeks earlier – literally “hiding in the walls”.
Early September – Having reviewed the state of the project I talked to our engineering manager and product owner and said “this project is f***ed, do you want to kill it?” The response was “No, we believe this is the most important and valuable thing we can be doing right now.”
Late September – After the first attempts at recovery still hadn’t achieved enough I re-asked the same question – the reply was the same
Mid-October – And again. All the while the team are still working away trying to deliver.
Late October – Our Product Manager (not the Product Owner) finally decided the project needed a reset. The forecasts had finally tipped him over the edge and the total cost wasn’t acceptable. (This coincided with our push to get an Alpha release into the hands of users for concrete feedback.)
Mid-November – We shipped an alpha release to validate our new UI technology and started building plans and options for the finished product release.
Mid-November – We sought input from the team on options on how to exit the project gracefully. (there’s an entire article on this experience waiting to be written)
End November – We killed the project and I started on building a plan to move on – leaving the team with a new manager and have them successfully working on a new release by the end of January
December – A general lull. Recovery time. We had Down-tools week, holiday period, some bug fixing and a couple of the team started investigating the next feature. My replacement joined the team and we started on a gentle 2-3 month handover.
January – When the team returned from holidays we decided to start on the “new” feature (actually finishing a feature started 2 years earlier and never finished). One of my team had the task of reviewing current behaviour and delivering a demo to the team. This was eye-opening. The scope that had been implied from PO conversations didn’t address the fact that the feature was barely usable.
Mid-January – Over the 3 weeks this new feature had started (as a “3 month” project) scope had ballooned again to include rewriting a fundamental aspect of how data would be stored.
Mid-January – Team mutiny (During a retrospective). The feedback was honest and painful but most importantly it was actionable and had cemented the worries I already had – things were broken again and we needed to hit the reset button a second time. Although he was already on board, this was not the time to hand over to my replacement.
End January – Reset time. Feedback in hand, we had to act fast. I redesigned the entire way work flowed into and through the team, gave some direct and difficult feedback to our new product manager, engaged him in the reset and briefed the team on changes.
Mid February – With the reset well under way and team morale already on the increase I could safely hand ownership over without feeling guilty about the state of the project.
But what went wrong?
There were a catalogue of problems raised by the team. Here’ the points the team raised…
- We talk about “quick wins” but never do them
- Poor control of scope for the last 2 major projects
- A team of 10 with 4 managers is consistently underperforming another team of 3 with no management – why is that?
- The project backlog is only technical tasks, not user stories
- We still don’t know what the focus of the next product version is
- We’re deeply worried about the quality of the next feature (based on current scope)
- We’re not bought into the new feature work – we’re repeatedly told users don’t need it and it’s just a checkbox
- We want to be more reactive to support requests
- We’re not delivering quickly to users or responding to their feedback
- We want to feel proud of the product and what we’re delivering
- The work isn’t structured to be delivered iteratively
- There’s a complete lack of user perspective on upcoming work
- Despite 4 managers, we have no leadership.
Brutal – but completely valid
For the last 6-12 months we’d been entirely focused on helping the team deliver what the business had been asking for. This was a good team. Sure they’d had a lot of technical problems on the previous project but the new one should have been different.
Both projects started with a technical requirement – rewrite X, finish Y.
This built some odd behaviour into the team. They were at the mercy of the backlog. They couldn’t self-organize, they couldn’t deliver iteratively, they couldn’t manage scope, they couldn’t even decide the best solution for our users. Everything was pre-defined.
I hadn’t spotted the problem for months. I’d been so focused on delivery of what we’d been given that I failed to identify the biggest issue was the incoming work itself!
After killing this second project, the next feature on the list was called “Implement Z” – where Z was a half-written product (again).
I now have two “stop” phrases added to my list of dangerous projects;
These are gross generalisation phrases much like “finish X” or “Implement Z”, they’re the smell of unbounded requirements. Taking them at face-value and accepting work into the team is a recipe for failure. Both failed features started out on the same two flawed premises but beyond that, take another look at the list of issues raised by the team.
We’d let the team down. We were managing poorly, not leading and the features were not user-facing. They might once have been but not by the time they reached the team.
How do things look now?
First we clarified who in the management team was responsible for what. Who was “in charge” from the business, who was “supporting” and who was “managing”.
Then we restructured our view and approach to incoming work into 4 balanced streams with clear constraints, policies and ownership for each.
This is probably best explained using the presentation I ran with the team…
We asked the team during the presentation who would be willing to take on the role of “feature lead” for upcoming features. Every hand in the room went up!
We’re just reaching the 2 month checkpoint and things are significantly better.
- The fixes and achievable streams are generally running smoothly and shipping frequent product updates.
- The team have learned what sizes of work and level of understanding do/don’t work well as “achievable” items.
- The feature lead role and relationship with the business is successfully flushing out real user needs.
- The analysis/discovery stream took longer than the team were hoping for but development of the first major feature off the back of the research work has just started.
- The team completed their first user story mapping session to plan a genuinely iterative set of potential releases.
- The first iteration of a new major feature is (optimistically) planned to finish in 2 sprints.
- At any point after the initial release we could stop and move on to something else.
- After the first release the team will have the ability to run UX sessions, gather feedback and adjust plans based on real user responses.
- The team’s new project manager has been able to take his sabbatical and leave the running of the project to the team for 6 weeks! (with occasional check-ins and support from me)
Better still, Nick (my successor) has been gathering measurable feedback from the team since we started the reset. Here’s the data.
From Architectural Decoupling to a Complete Rewrite
For a lesson in what not to do, here’s the gory detail on the first project that was killed.
The project goal was to “make it significantly easier to change the UI in future” – delivering value to internal stakeholders in the form of efficiency and quality savings.
This was conceived as “3 month” project back in April but ran into trouble over the summer. The PMs involved in the start of the project had assembled enough project data to establish “This could take anything up to another 1-2 years to complete”.
The project scope had changed from architectural decoupling to a an internal technology refresh and from a technology refresh to a pilot for a new (unfinished) product style guide, a complete UI replacement, implementing a set of untried technologies with a team that had little or no experience of using those technologies and improving the user experience of the UI along the way.
Essentially they were going for a complete unbounded UI rewrite.
The initial idea was to introduce the new UI as an MVP alongside the old UI with limited functionality and support for end-to-end workflows.
Somewhere in the course of time the “end-to-end” part of this had been lost.
By the time I joined, the implementation approach had become replacing whole tabs of the UI, developing multiple tabs in parallel to improve and validate code reuse and completing these widget-by-widget rather than by workflow.
On the surface, technically this seemed sensible. It reduced rework and kept architectural quality high.
I made things worse by pointing out that an MVP wasn’t viable for a product whose broad set of features were in daily use by over 1,000 customers. Thus it became a “like for like” replacement project – of which so many end up doomed by a big bang approach and repeated delays as scope is discovered!
Shipping a new release with significantly cut-down functionality is a big gamble and usually only one you can take if you have something else of significant value to offer to the customer.
In fact, the most commonly requested feature from our customers – a rewrite of some particularly nasty functionality to support additional use cases and improve existing ones – wasn’t being worked on. We’d actually decided to remove the poorer version of that feature and not replace it until a future release.
In hindsight and from the outside this all seemed a bit nuts.
Before I joined the team, in my oversight role across all projects in the company I was aware of a nagging worry about the state of the project but I couldn’t put my finger on why. The reports and whiteboards seemed “ok” or “meh” but not fundamentally bad.
This is now another warning sign to us when reviewing project status. Month after month of “ok” (not “good”) status across an entire series of checks is a smell (see “Yellow is the new Green” )
I repeatedly asked about any deadlines, due dates and what was going on and received reassurance that everything was under control but there weren’t any real deadlines so everything was still “OK”.
As “Head of Project Management” I have to admit it’s pretty embarrassing to not have tackled this wave of trouble. I and others in the leadership teams saw it coming but trusted the feedback we were seeing. We continued to treat everyone as knowing what needed to be done and safe to be able to do so (“S4” in Situational Leadership terms) when actually they were in trouble and needed help. (“D2” level).
Things came to a head at the beginning of August with the project on the rocks, one PM left and another wanted to go back to a development role.
Determined not to face a “Netscape project” I joined the team to get things back on an even keel. Until now, I’d never had a project I couldn’t salvage quickly – usually in under a couple of weeks. This one was definitely much more of a challenge.
Fortunately the team had backlog and historic size & velocity data so we at least had a baseline to work from (the outgoing PM pointed out that the estimates were wildly inconsistent and hard to trust).
Step 1 – We visualised the entire scope of the UI and discovered some 30+ dialogues and little-used screens that could be postponed. We took a scythe to the scope listed in the backlog based on this visualisation and managed to improve the forecast delivery dates.
Step 2 – I was unhappy that the partial backlog on the wall didn’t offer easy traceability to the full digital backlog so I tagged up all the stories and reconciled the wall with the backlog in a spreadsheet and discovered another 50% of scope hiding in the walls.
At this point the project had ballooned beyond all recognition of the original. We’d dropped into sunk costs and the approach to delivery had removed our ability to deliver iteratively.
Every sprint that passed uncovered more technical problems and more missed scope. Some major performance issues with the new technology tripped the team up for weeks and even after shutting the project down, taking what was delivered as an Alpha in November, salvaging the most complete parts and getting it shippable involved 3 more months of stabilising the technology – insanity!
Fortunately, the salvaged tech finally paid off. After releasing the main work, the team were able to deliver a series of small enhancements near weekly for the next month.
They’re through the worst now and I’m moving onto another team.
The team did a great job staying sane in spite of the craziness around them and both they and “management” have learned a lot . What we have in place now goes beyond preventing a repeat of all these problems – it resets the whole way they work to focus on customer needs, customer problems and customer value. It gives them space and freedom to self-organise whilst balancing the needs of the business when necessary.
I’m sad it took nearly 9 months to get here but glad we’re finally on the right track.
We’re also using the lessons from here to ensure other projects that threaten a rewrite focus on incrementally delivering end user value by only rewriting areas that directly improve a team’s ability to deliver on the next customer-facing changes and features.
Update – 24th April 2015:
I had a chat with one of the team who reviewed this for me. Other than some tweaks to the early timeline he mentioned that as of a couple of weeks ago the team have now actually deleted about 2/3 of the UI code that was developed but never finished. That’s a really brave move given the effort they all put if but they found it was holding them back in adding new features (using the new UI technology in smaller increments).
He also mentioned that the first new feature to run through the updated team analysis process is flying – a way better start than the last!
They’re is still a great team and have really turned the corner by the looks of things now.