In search of the viral loop

Cross-posted from Zolo Labs.

Just finished reading Viral Loop. As we think about the distribution side of things for Zolodeck, I figured it couldn’t hurt to read about how a bunch of companies achieved massive scale.

It’s a good read… and certainly describes how things were done at companies like Hotmail, Twitter, Facebook, Hot Or Not (remember?), Bebo (remember?), MySpace (remember?), eBay, Flickr, PayPal, and even Tupperware (yeah, really).

It isn’t, however, a book of recipes. I didn’t really expect a book to be able to just tell me the 10 things I can do to fix distribution, I guess, and on that count the book was merely describing how awesome it is when you do achieve massive scale. Not how to get it.

Still, a very decent read, and did trigger a few thoughts for what one can do to address this. A lot of people in the startup space know this already, but it’s been sinking in for me more and more over the past few months: distribution is the more important of the two key things a startup needs to solve (the other being product/market fit, or product in general). And also that distribution is the harder of the two problems, and more than product, it is distribution that will make or break the company.

As I said, we’re thinking a lot about this for Zolodeck… and since this is so important, we’re erring on the side of over-measuring things to ensure we can keep a pulse on what the distribution story is looking like. What else can one do at such an early stage?

Make something people want

Cross-posted from Zolo Labs.

I’ve been reading Paul Graham’s essays for a long time: since 2001, when an old friend introduced them to me. I was excited by the way he writes about startups and what startups can accomplish. In my head, startups are like the Rebel Alliance, with the odds heavily stacked against them, and they battle the various Death Star corporations for a slice of the business, to institute a smarter way of doing things.

I was also heavily influenced by his articles on Lisp, particularly this one. It’s why I started playing with various Lisps, and why I was so excited by Clojure, and why I wholeheartedly embraced it.

But this post isn’t about technology. It’s about the Rebel Alliance. It’s about two guys in a makeshift office, in the proverbial garage somewhere. Startup statistics can be quite depressing, with 19 of every 20 startups doomed to failure. With such a low rate of success, how do the successful ones do it?

I remember reading this article by Paul Graham, and thinking it makes sense. I remember it making sense in a very superficial, non-committal sort of way. The core of the statement: “Make something people want” seemed perfectly obvious to me. How could you succeed if you didn’t make something people wanted? Duh. Right?

I’ve been spending a lot of time thinking about Zolodeck, the depth of this idea is actually hitting me quite hard. There are two parts of any tech startup: the product side, and the distribution side. The product side is about finding the product/market fit, about making sure the experience is right, and that what you charge for the product is more than what it costs to make. The distribution side is about customer acquisition. Obviously, there’s interplay between the two sides.

“Make something people want” is a simple recipe for success. It seems to distill everything the Lean movement talks about into a single sentence: is your startup making something people want? Everything else is details (of course, the devil is in the details, and you need the details to succeed). In the end, you have to collect and collate the metrics that will point you to what it is that people want, and that will tell you how and what your startup should be doing. But the overarching guiding principle is very sound: make something people want.

And yet, a lot of startups fail because ultimately they don’t end up building something that enough people find value in. Or perhaps at a cost that was lesser than what they could charge for it.  Making something people want doesn’t mean that if you build something incredibly powerful and useful, but at a gargantuan price, you’ll succeed. The something you build for people needs to solve an equation that involves cost, price, scale, and utility.

So back to the two guys in their garage. If you’re a tiny startup (in reality or in spirit), you can greatly increase your chances of success by using this mantra as a guiding light: make something people want. And make use of Lean metrics to see if you’re trending towards a success or failure. I really do believe that if done right (pick the right metrics, and make adjustments based on what they say), a startup can succeed. And given the stats on startups, this is a bold claim.

I plan to share our Lean metrics dashboard and overall progress as we continue to work on Zolodeck. I think of it like a public experiment. Hopefully, we’ll discover something of value, and others can benefit too! Go Rebel Alliance!

Designer-driven vs. metrics-driven product design

Cross-posted to Zolo Labs.

An interesting question cropped up over dinner the other night – does metrics-driven design have any place in the world of designer-driven product design? For instance, Apple is famous for not using focus groups and so on, and instead relies on their own processes and practices to develop their amazing products.

I’m a huge believer in Lean methods for developing products and building a business (I’ve written about this before, and spoken about it as well). I’m also a huge Apple fan-boy (yes, I wept when Jobs passed). And obviously, Apple does a lot of things right when it comes to developing products.

So how do these two ways of driving product design mesh with each other?

My point of view is that they’re not mutually exclusive. While there’s no substitute for vision (and thereby designer-driven product creation), metrics can serve as an excellent sanity check. They’re really guard-rails, guide-posts, safety-net, compass, or whatever analogy you want to use. They can be especially useful when the product is in a “new category” and where there may not be established usage patterns or user behaviors to draw from.

If you buy into the “iterations are awesome, fail-fast, learn-improve-repeat” process, then you really can’t do it without metrics. And, of course, you need the right metrics, but that can be a post for another day.

Metrics Driven Product Design

Cross-posted to Zolo Labs.

I’ve had some downtime from work recently, and have been working on a side project with a friend. (Isn’t that what vacations are for?) We’re calling it Zolodeck. One of the first things we did is decide that we want this to be driven completely by future users. So this is an experiment in user-driven product design, you might say.

Technically, we’re tracking everything that a user can do. This data gets fed into our data-digester. Yes, that’s the technical term. And out comes Insight. The idea is to use these insights to decide how to evolve the project.

We’re looking at several ways in which we can get the infrastructure to support all this, including building out our own. I know it will be a complete distraction from the goal of the project, so I’m certain we won’t go down that route. We’re still evaluating what we’ll end up with, so stay tuned on that. We do want to document our experiment here, so this notion of “metrics driven product design” should be a recurrent theme on this blog.

BTW, we’ll also add convenient text-boxes that users can use to drop us notes (mostly appreciative suggestions, but also hate-mail if they choose 🙂 ).

Announcing the Bay Area Lean Software Development Meetup

Hi folks, I’d like to announce the Bay Area Lean Software Development Meetup. The first meeting is scheduled for the end of the this month – on the 30th of April.

I’m going to present on the topic that I’m presenting at the Lean & Kanban 2009 conference – and the topic is Lean Software Development for Startups.

This is just the first meetup, so it will be general – exchanging ideas about what different folks in the valley are doing with their software processes… and things like that.

Join the group – and attend, it should be fun!

Adopting lean software development: What is a user story?

I recently got an email from a reader (Dmitry Lobanov) who had some questions about the process stuff I’ve written about here. With his permission, I’ve reproduced the contents of his email and have responded to his queries. It may help other folks that are in early stages of adopting lean/agile methods –

Hello Amit. You keep interesting blog with a lot of useful information about project management. To my opinion the most attractive idea in your blog is user stories decoupling.

Let me tell how I found it interesting and then I’ll ask a few questions, Ok?

In our project we use scrum with some XP techniques. I found link to your blog in an overview of Mingle at Thoughtworks website. While reading I found your idea of decoupling stories into 2 story points tasks very interesting. And I think, that it makes sense. We tried to compare two approaches (yours and card poker) while estimating amount of time required for 1 specific user story. Well, it is not 100% your approach in fact, because we still tried to use estimation and ideal days, but we took your idea concerning 2 story points tasks. But we are not ready to forget about estimation yet 🙂

First we estimated using card poker, and then repeated estimation using your approach. And we found the following advantages of your approach:
– your approach gave us complicated tree of concrete task. That means that we could just take them and start working on this user story, we know what and how should be done. In other words we have got a plan! Card poker didn’t force us to decouple user story into atomic tasks and just gave us list of generalized tasks (which themselves can be user stories).
– card poker estimation gave us some number of story points (we used ideal days according to scrum guidelines), let it be X ideal days. And then we used your approach for estimation: number of atomic tasks multiplied by 2 story points (we still use ideal days 🙂 ), let it be Y ideal days. And we have been amazed, that Y was 10 times greater than X! 10 times! That’s too much.

This experiment shows us that standard estimation lacks of accuracy a lot… well, we suspected it, but only after experiment we saw it clearly. And using card poker (i.e. bad decoupling) we constantly have problems with developers got stuck in development process, and as a result they do 5-days task for 2 weeks or even more. We have one user story, which had been estimated as 8 days, but two developers work on it for 2 sprints already. It’s no good at all.
So in the near sprint we’ll try decoupling user stories into 2 story points tasks and watch the result.

I have a couple of questions about decoupling and sprint planning, and it would be nice if you provide your point of view concerning them.

In your post about requirements management (http://epistemologic.com/2007/04/08/requirements-management-user-stories-mind-maps-and-story-trees/) you touched only initial planing. But what to do with bugs and technical tasks? I’ll explain. Look, our project has been in development for 2 years, we develop payment acceptance system. And our system has been in use for a bit less than 2 years (it took approximately 3 moths to issue first release). So it changes constantly, we issue new release every 2-3 weeks. But when the development started, team suffers a lot from a lack of project management experience. I came to project few months ago (I’m not a project manager, just developer, who wants to improve project). Now situation seems to improve. But we have a LOT of bugs. As you understand, these bugs can’t be attached to specific user story, moreover we hadn’t user stories before, in fact we introduced scrum only 2-3 moths ago.

For example we need to fix one bug (one of many) concerning working with hardware. And we clearly understand, that we need to refactor part of our system, which works with hardware. It could take a lot of time, we understand that we need to add hardware manager, change hardware interfaces and so fouth in order to unify working with hardware. And it should be done, because if we just fix bug not changing anything, then literally tomorrow we’ll have to fix similar bug, and then another one, e.t.c. How this task should be registered? It is not a user story, because product owner (or stake-holders) wouldn’t see the result, they wouldn’t be able to “touch” it, it can’t be demonstrated to them. And it is not a defect for particular user story, because it is the behaivour of legacy code, we haven’t corresponding user story. What should we do?

I see only one solution. We should wait till stakeholders give us user story concerned this functionality. For example, stakeholders want us to add support for a new type of device. Hence we can include refactoring task to a bunch of tasks under this user story.

But our system has been in development for a long time, and we added support for a lot of devices already. So it can take a lot of time till suitable user story will appear. And we should just wait and fix bugs?

And how to register bugs if we don’t have corresponding user story?

Another one situation we faced yesterday. If we have user story, which involves a lot of changes in architecture. That is user story contains a lot of task, but these task can’t be accomplished separately, and they are not user stories themselves, because they are technical tasks (refactoring and researches). It’s clear that we can’t show them to stakeholders, but we can’t accomplish user story not accomplishing these tasks. And we think, that we won’t be able to accomplish all these tasks in one sprint. And I don’t know how we can decouple 1 user story intro several user stories. What should be done?

Correct me please if I am wrong in my interpretation of user stories. I think that user story is “something” useful to stakeholder. Stakeholders can “touch” user story, they can take a look at it, they can play with new functionality and so fourth. Hence anything that can’t be demonstrated to stakeholders is not a user story, is it so? Stakeholders are not interested in tasks, they want to know only 2 things: What and When, they don’t want to know How.

And I have another one question concerning terminology. What does “epic story” mean in terms of user stories? How does it compare to user stories?

Looking forward to your reply.

Best regards,
Dmitry Lobanov

OK – so here’s my take on the questions raised:

User stories: I’ve had to deal with the question of what a user story is quite a few times over the years. There are many theoretical definitions – and I don’t care about most of them. In my opinion, the only thing that matters is this – a user-story should add business value. That raises the obvious – shouldn’t everything you do while working on a project satisfy this criteria? Yes, it should – and this is usually something that business stake-holders understand quite well.

There are several kinds of stories. The first is the obvious “feature” stories that have a GUI etc. This is the category of stories that can be “touched” and is “tangible”. Justifying this one is easy – indeed, these are the ones most commonly requested by the business.

Then there are the “technical” stories that don’t have a UI – e.g. – “store the uploaded data in a compressed format because the space used up by the system right now is costing us too much money”. Again, the value is obvious.

The next category is bugs – fixing these delivers clear value and are no trouble to manage as such. See below for more information.

One other type of story is the spike. These are easy to deal with since it is obvious what value they deliver – namely an experiment to determine if an approach might work.

The final variation is stories that deal with paying down technical debt. These are harder to justify because the business is usually not technical enough to understand these. There is no easy answer to how to sell these – but there is usually a very tangible benefit that can be attained by playing these cards. Usually this benefit is deferred – allowing the team to build new features faster, or reduce the number of bugs being discovered in a subsystem. When put in these terms the business is usually quick to understand – and then it boils down to a question of ROI. The cost of implementing these cards should be less than the savings they represent. It is important for everyone on the team to see the whole – and make these decisions together. The key is to sell the business on the value these stories delivers as opposed to the technical details. And by the way, this should be done whenever the debt starts to weigh heavier than what it should. A clean code-base is a happy code-base.

How to deal with bugs: The short answer is I usually treat bugs as stories. They don’t need to be associated with a specific user story. A bug is a bug – it doesn’t matter how it came to be – (of course, it is often related to a story – and most often the same developer ends up fixing such bugs) – and I track them in the same system used for stories. I also let the same prioritization process determine which ones get fixed and when. Further, some bugs are so tiny that they may even get fixed without there being any record of them at all. Some are so large that they might actually result in multiple stories – especially if a redesign is required. Keeping in mind that it is cheaper to fix bugs sooner than later, bugs can be managed just like any other story.

So – to recap, I don’t care for the theoretical definition of user-stories – that they should be tangible and what not. Instead, I recommend that folks do what makes sense for their situation. If I had to give only one tip around stories, it would be this – keep them small. This mnemonic might help.

Finally – about epic stories. An epic is merely a feature (or some technical aspect of the system) that is way too large to be completed as a single user-story. It is epic, because it is a large story 🙂 I always keep playable stories down to less than 2 days in length – as far as possible. Epic stories, therefore, must be managed by breaking them down into incremental chunks of functionality. This is possible about 95% of the time – sometimes however when some spike is involved or some hairy technical refactoring is needed – longer stories can be played.

I hope these thoughts answer some of the questions. I’m sure other folks have different experiences and different solutions to these issues – and that’s fine too, since agile is all about adapting.