Almost a year ago I wrote a post to propose/summarize a universal model for product development.  I’ve now refined that model into what I believe is much closer to what the original intention was: a product development framework that is detailed enough to be practically usable, but generic enough to fit on top of any development paradigm (Agile, Waterfall, etc.).

I’ve decided to start a series of posts on software development and the Product Manager’s role in that process.  The first, this one, is a very general overview — it’s basic, yes, but necessary to lay the groundwork.  After that, I want to spend time writing down my thoughts on each of these stages in detail.

Why do this? Because I think the Product Management profession is finally starting to come into its own, and I’m hoping that through discussion we can, together, evolve a practical guide to what we do from day to day, something that is both flexible enough and rigid enough to be helpful without being constricting.  And maybe also just to force myself to think through this in detail and become more deliberate and focused on each of these steps.  I hope you’ll join the discussion!

I won’t be talking about scheduling, scrum methodology, or team organization in these posts.  The goal is to focus on the work that needs to be done — whether it’s being done by an individual or a core team is not the focus here, and will be different depending on the company, the philosophy, and the team.

So let’s start here — a diagram of a proposed universal model for software product development:

Borrowing from and expanding on my original post, I want to make a few observations. First, there are a few assumptions that are important to note about this model:

• Regardless of the development methodology, representatives from Product, Marketing, Business, Design, and Engineering should be involved to some extent from the very beginning of the process. Once detailed requirements are being written, it largely becomes an Engineering and Product effort to ensure momentum and avoid the dangers of design by committee, best summed up by Dilbert:

• Having said that, it is important for one person to own this process (i.e. be accountable for its success) from start to finish, and that person should be the Product Manager/Product Owner. A good product manager is not a dictator. He/she is a facilitator between all the different stakeholders of a product, and the really good ones are able to get through this model on time and on budget, every time and with as much consensus between groups as possible.
• The roles of the Responsible (R), Supporter (S), and Informed (I) are important to define for each of these steps.  Most important is that there should be only one “R” for each step.  This doesn’t necessarily mean it’s the person who does all the work, but it’s the person who is ultimately responsible to get the work done (with help from the “S”es).
• This model is designed to work for any organizational structure, project size, and timeline. If the project is large, more time can be spent on each step. If the project has a tight timeline, it doesn’t mean that you will skip the “Iterate” part of “Design + Iterate.” It just means that you will spend less time on it (more on that later).

Summary of the different aspects of the model

The rest of this series will be devoted to detailed discussions about this model. My goal with this post is to be general and make one or two points about each aspect. So let’s look at some definitions and implications of the model:

• The starting point - identifying needs. At the beginning of any project (new or iterative), it is important to gather and synthesize input from three different sources:
  • User needs. Everyone needs to have a good understand of the market, the target segments, and their behaviors and attitudes. There’s not enough room to go into detail here, but it is important to look at four sources of user input: market research (segmentation, etc.), user experience research (usability studies, ethnographic explorations), site analytics (behavioral analysis), and customer support (call transcripts, interviews with CS reps, etc.). Having this common understanding allows the organization to build products that matter to users.
  • Business needs. User experience practitioners too often neglect the fact that well, your site has to make money! Revenue goals are not a good excuse for bad design, and that attainable revenue goals are essential to push the organization to design good product.
  • Technology needs. Engineering needs to be at the table from the start. They know the limitations of the product, they know what needs to be fixed, they know what technical debt needs to be paid down. Having engineering and product working together is essential in good product development.
• Requirements gathering. Pragmatic Marketing, in a post entitled “On Reqs and Specs: The Roles and Behaviors for Effective Product Definition,” proposes some solid definitions for the three different documentation outcomes in this model: Requirements, Functional specifications, and Technical specifications. The first outcome from the discussion and synthesis of needs is a common understanding of the problem statement you are trying to address, which takes the form of Requirements. A requirement is simply a short statement of the problem, and Pragmatic Marketing recommends the following format: “Our preference is the Requirements That Work format: [Persona] has [problem] with [frequency]. It forces product managers to explore the problem, not the solution, and helps the design team understand the context of the problem.”
• Solution brainstorming. Once the problem has been defined and agreed upon, the team starts thinking about solutions, usually through some form of design thinking or abductive reasoning. There are three important aspects of this phase, which is often called Product Discovery:
  • Start with blue sky ideation (divergent thinking). At this point, don’t limit solutions by what is technically or otherwise feasible. Spend time dreaming about the product - this is where innovation happens!
  • Relentlessly prioritize (convergent thinking). This is the part of the process where nonsensical ideas are thrown out, and the team consolidates around a few possible solutions to the problem that can be further explored. Remember: there is no commitment to implementation or specific designs yet at this phase.
  • Apply the technology filter only after the ideation phase. There is a very important technology filter that needs to be applied during prioritization. What is technically feasible? If something is currently not feasible, what would it cost to build the right architecture? Those early inputs can save a lot of headache down the road.
• Flow charting and wireframing. This phase starts to put some flesh around the second output document, Functional specifications, which Joel Spolsky defines as follows: “A functional specification describes how a product will work entirely from the user’s perspective. It doesn’t care how the thing is implemented. It talks about features. It specifies screens, menus, dialogs, and so on.” At this point visual design is still left out of the picture, all you are doing is defining flows and interactions.
• High-fidelity mockups. In this phase, visual design gets involved to design the experience as it will look on the screen.  If there are pre-defined patterns and standards (as is hopefully this case), this could be a pretty light step, but I do believe it is important, even in an agile environment, not to leave this part up to chance.
• Technical specifications. Development can start before the full designs have been completed.  Once the flow and interaction are sorted out, you do in most cases have enough information to start task breakdown and implementation.  Quoting Joel Spolsky again, “A technical specification describes the internal implementation of the program. It talks about data structures, relational database models, choice of programming languages and tools, algorithms, etc.”
• Build, discuss, iterate. Everyone designs a product, but it is sad to see that when time/budget gets tight, iterating on it before it goes live is often the first part of the process to fly out the window. It cannot be overstated how important it is to prototype and test your designs before they go live. And not having time is really no excuse. If you have no time, make a paper prototype and test it with three of your friends over coffee in the evening. You’d be surprised how much value this can add. Boxes and Arrows has a great article on prototyping and how to integrate it with your design process that’s well worth the read.
• QA, release, assess. After the thrill of releasing, the assessment phase is extremely important and often overlooked. It is important to define your measures of success upfront, and then follow up to see if you’ve met those goals. How do users respond to the product? Are we meeting revenue/engagement goals? What can we learn from how users interact with the product to give us ideas for new products? I’m also an advocate for using the same four sources of input we discussed earlier (market research, user experience research, site analytics, and customer support), as opposed to relying on only one methodology, like a 3-week A/B test. More on the dangers of that in one of my earlier posts.

Where we go from here

So now that the stage is set, what happens next?  Over the next weeks and months, I’d like to write a detailed post on each of these phases, particularly from a Product Management perspective, and what the role of the PM/PO is during each of the phases.

There are, of course, lots of resources out there for Product Managers, but I’m hoping to talk more practice than theory here, and hopefully generate some discussion (and disagreements!) to help us reflect on our chosen profession.

PS Big hat tip to @justinspratt who gave me the nudge I needed to start this series.  He is the real deal, despite being Australian.

I read quite a few excellent UX/PM posts this week, and wanted to make sure you don’t miss out.  So here are some excerpts from my favorite posts of the week.

User Experience Design in the Agile context

In Agile UX and The One Change That Changes Everything, Anders Ramsy writes about how user experience design can be adopted to fit the agile mold a little better.  He calls for less design up-front to basically embrace the MVP approach instead of fighting it:

The first and probably most fundamental change to flow out of starting to build earlier is that of chopping your up-front design phase down to a fraction of what it might be in a traditional model to allow for establishing a foundation of working software, and then evolving the rest of the product on top of that foundation. In other words, we go from Big Design Up Front to Just Enough Design Up Front.

The rest of the post is devoted to how to do that, including thoughts on lighter, conversation-centered documentation, and the importance of collaborative design.

Enough with the “chicken & pig” story

Speaking of Agile, David Bland wrote an impassioned post arguing that Our Divisive Scrum Terminology Needs to be Deprecated:

Scrum teams succeed or fail as a, well, a team.

If the Product Owner is confused about the role or not living up to expectations, it is the ScrumMaster who should be helping them along the way. If the ScrumMaster is failing at coaching up the Product Owner on the framework, then wouldn’t the ScrumMaster be to blame? But wait, since the team has appointed the ScrumMaster, would they not have failed by choosing one who is incompetent?

W’ll just run in circles pointing fingers because there is no easy answer, and using the Product Owner as the scape goat does nothing to help resolve the situation.

Measurement-driven Product Management

The always brilliant Pragmatic Marketing has a post entitled Measurement-Driven Product Management that should make all of us a little uncomfortable.  But good uncomfortable.  Getting better at your job uncomfortable.  Read the post for details on the proposed ways to measure the success of PM, but this is why they make the case for it:

The long term benefit of Product Management becoming measurement-driven is higher team performance, improved predictability and increased credibility. The ultimate benefit is developing the ability to reliably create outstanding products and market breakthroughs.

Can Product Management operate with this high level of maturity, using a reliable measurements and metrics system with more predictable results in a company?

This “holy grail” of product management performance is doable, but often many cultural and process gaps must be addressed first. An organization fosters a measurement-driven culture by reinforcing other aspects of the process, such as tightly coupling rewards, recognition, compensation and promotion to attainment of operational results. Does yours?

Research and Design, sitting in a tree…

In The product of a healthy relationship, Paul Golden discusses the sometimes rocky relationship between researchers and designers:

Hana Thomas of design consultancy Smallfry agrees that while market research can play a crucial role in product design and development, there are dangers. “There can be an over-reliance on market research, which leads to it being used either as a scapegoat for poor decisions or employed too soon in the creative process, stopping ideas in their tracks before they have even had the chance to be realised.”

Thomas refers to the value of ethnographic research to her company’s work in product development and describes studying people in their own environment, under a relevant context, as the “ideal way” to truly unearth latent needs and desires.

According to Reon Brand, the responsive and listening brand that engages its audiences in the creative process as well as in dialogue has a major advantage in our increasingly social-media driven world. However, all research methodologies have their limitations. While consumers can react to what exists and relate back to what they know, some of the designers surveyed by the Design Council felt that consumers were less able to contribute to the development of completely new product or service concepts for the future.

I just became the mayor of someplace you’ve never heard of

On a slightly different note, I found this RWW called Why We Check In: The Reasons People Use Location-Based Social Networks very interesting.  It presents some research on why we use services like Foursquare and Gowalla, and there are definitely some surprises, like using it to keep track of history:

The thing that surprised me most when I asked people why they use location-based social networks is how many of them say they use it primarily to track their own personal history. It’s a lazy diary, people say.  Some people say they use it to help with their expense tracking on business travels.

Happy reading!

One of the hardest parts of Agile development, but also one of the most powerful and rewarding, is figuring out how to make the process work for the team you’re part of.  Even though the guidelines are clear, there is simply no “one size fits all” approach when it comes to Agile.

We as Product Owners need to loosen up a little when it comes to pre-determined process, and work with our development teams to design an Agile process that works for everyone involved.  With this in mind, developer @darb and I evolved the following sprint guidelines for one of the applications we are responsible for here at Yola.

The ingredients of a good sprint

Every two weeks we sit down and discuss the next sprint, and we make sure the following ingredients are included:

• 1 x silly name. Darb is partial to automatic Linux-generated names like Thundering Tuatara.  I am partial to non-silly names like “Sprint 3”.  But he won this argument — it’s all a game of give-and-take.
• 1 x revenue-related. Every sprint has to include at least one bug fix, enhancement or feature that will improve our top-line revenue.  We are a business, after all, and this part is too often neglected by Product Owners.
• 1 x front-end maintenance. With every sprint we have to make an improvement that customers will notice.  This can be small visual tweaks to increase usability, or bigger overhauls of the interface based on customer feedback and analytics.
• 1 x back-end maintenance. Performance improvements and general back-end maintenance get put on the back burner way too easily - and as Product Owners we are often very guilty of deprioritizing maintenance because you can’t immediately see the effects of working on this.  But balance is extremely important, and paying down technical debt needs to be part of every sprint.
• 1 x error messaging/UX improvement. This is related to front-end maintenance but different in that these tickets aim to address user experience and usability improvements mainly through changes in the interaction, not necessarily the visual design.

It’s important to note that these buckets aren’t mutually exclusive, so some tickets will address more than one issue — and that’s even better.  This is also the minimum requirement, usually we try to get a good balance of all kinds of tickets into a sprint.

The recipe for a good sprint

In addition to these minimum requirements of what should go into each sprint, we put together the following guidelines:

- Leave time for ad hoc planning and work.  Other stuff will always come up.  Don’t let it make you miss your deadlines — leave room for it so that you have “planned outages” in your sprint work.

• Make sure there is a good mix of big and small size/complexity tickets.  Momentum is so important.  Seth Godin talks often about the importance of shipping often, and to do that, you have to bite off manageable chunks of work.  Make that small text edit that’s been on the backlog for months because it’s just too small to schedule.  And couple that with bigger tasks that get you closer to your overall product vision.
• Make effective use of priority. We use Jira to track our projects, and we use Priority to schedule the order of work.  We have to get P2 and P3 projects done in the sprint.  P4 and P5 projects are nice to have, and we do them if there is time.  For P1 work, see the first bullet…
• Stir Rian into vitriol. I’m not sure why it is important for Darb to find new ways to freak me out every week, but he seems to thrive on it, so this remains in the recipe for now.
• Simmer in QA by mid 2nd week.  It’s such a simple thing, but so many organizations forget that for something to release on Thursday, it doesn’t mean that first round development is completed by Thursday morning.  It means that at least some first round development needs to be completed by Tuesday morning so that QA can start.
• Rinse and repeat.  And then we do it all over again.

The “ingredients” and recipe are very specific to the application that Darb is the lead developer on, which is our payment system — with all its many back-end and front-end complexities.  Obviously different applications need different ingredients.  On our website, for example, we place a lot more focus on front-end than back-end.

And I think that’s the point I’m trying to make — that the best product development process is the one that Product and Engineering agrees on, and it never looks exactly the same across all applications.

I recently realized that you don’t hear the word “globalization” all that often any more.  And I think it’s because globalization has moved from being a buzz word to a reality that is just part of the way we do business now, making it unnecessary to give it a fancy name.  As we become more comfortable with managing companies and projects across multiple locations, it’s easy to assume that geography does not matter any more.  And certainly the technology is there to support the around-the-clock collaboration that is so valuable when you work across time zones.  With cloud computing now a reality, and plenty of collaboration applications to choose from, working together has never been more efficient.

But I believe geography does still matter, and can result in decreased efficiency if not managed correctly.  The difficulty with working across multiple locations is not technology limitations, it’s human nature.  We tend to not trust what we can’t see, and that’s a problem if developers, product managers, and marketing folks sit in different offices and different time zones.  Once different work philosophies come out and you’re not able to talk about it, things can escalate out of control and make for really bad relationships if conversations happen intra-office but not inter-office.

This is not an insurmountable problem though.  Here are some things I believe can help distributed teams run smoothly.  Please also add your tips and ideas in the comments section!

1. Meet in person. Now.

People get along so much better once they’ve shared a meal together.  This is just a fact of human nature — we thrive on in-person social interaction (yes, even us introverts).  If you have distributed teams, it is imperative that they meet each other in person as soon as they start working together.

If a trip can be planned during a major software release — even better.  Nothing binds people together like the stress and exhilaration of getting a new product out in the wild.  Work hard, but also make time to go have dinner together.  You’ll find that after the initial trip, you’re able to understand each other a lot better over IM/phone calls.  I do think it’s worth getting teams together at least once a year, but even if it’s just once at the beginning of the relationship, it will go a long way to improve working relationships.  So go ahead, spend the money on that trip.  It’s worth it.

2. Be respectful of time zones.

10am in San Francisco is 8pm in Cape Town.  Not a great time to have a meeting… Now, it won’t always be possible to line up time zones, but at the very least it’s important to trade off meeting times.  Don’t make the guy in the smaller office always dial in at 9pm.  Alternate between meeting times to give everyone a chance to have a life outside of work.  Try to have all night-time calls on one or two nights, not spread out across the week.  It’s the little things that count.

3. Use the right technology.

When it comes to collaboration across teams, there is no excuse for inefficiency.  We use the following applications, and I can highly recommend all of them:

• Google Docs and Dropbox for document collaboration
• Jira and Confluence (enterprise wiki) for bug tracking, product specs, and related discussions.
• Conceptshare for sharing and commenting on visual designs.
• Campfire for group chats during projects, and especially during product releases.  The Propane desktop app and the Ember iPhone app are great add-ons to Campfire.

4. Keep it human

One of the most important aspects of team dynamics — and especially distributed team dynamics — is not losing your sense of humor.  Even when things get really stressful, keeping funny alive is essential because it reminds you that there are real people on the other side of the phone line/email address.  And, of course, it relieves stress.

I’ll give an example from a project I recently worked on with a developer team in our Cape Town office.  They built an environment for us to test the new product flows, and the screens can live either in a website or a pop-up window.  The normal (boring) thing to do would be to put a link there that says “Open in pop-up” when you want to test the pop-up dialog version of the flow.  Instead, the developers called the link “Pop that collar,” and the following image appeared when you hovered over the link:

Now, I don’t know if they did this to amuse me or themselves, or a little but of both.  But for some reason the joke doesn’t get tired for me, and it made working on the project so much more enjoyable.  Always bring the funny on your projects.

5. Trust each other

A recent article called Forced compliance is an obstruction to discipline really got me thinking about trust within teams — especially distributed teams.  I agree with the author on how damaging it can be if team members don’t trust each other:

A forced compliance style of governance is a lot about trying to compensate for lack of trust and admitting that we are more likely to fail than succeed. On the other hand, discipline is not pain, suffering and anguish. It’s only sadistic if you implement discipline for nothing.

We need to trust our team members — they are (usually) smart people who do the things they do for a reason.  It doesn’t mean you don’t have tough conversations when someone makes a mistake.  But making a mistake doesn’t make you untrustworthy — who among us would be able to meet that bar of excellence anyway?  Ask questions before you judge…

6. Don’t stop talking, especially when you disagree

The book Crucial Conversations: Tools for Talking When Stakes are High is a must-read book about having those tough conversations when things do go wrong, or when disagreements arise.  At the heart of the book are tools to ensure that everyone on the team gets listened to, and that no discussions happen behind peoples’ backs.  I much rather prefer an open dialogue about a product disagreement, than having to find out 3 months after launch that someone on the team didn’t like the way we did things.  As Product Managers, our role is to gather information from a variety of sources and channel that into the best possible ideas and products.  How can we do that if we don’t listen to everyone?

I often remind myself that as Product Managers, we are not judged by the number of times we ask for input, or how often we change direction based on new and relevant information.  We are judged by the success of the live Product.  So why would we not want to hear everyone’s ideas upfront so that we can launch the best possible experience?

So these are a few principles I try my best to apply when working with teams on different continents.  But I have hardly figured it out, and we’re basically making this up as we go along.  I’d love to know your thoughts and ideas: how can distributed teams work better together?

There is a very interesting and healthy debate going on in the Agile Development world about Minimum Viable Product (particularly in startups).  Before I get into the topic I’d like to address today, I just want to do some positioning and say that in this debate, I currently (but am open to being convinced otherwise) side with writers like Andrew Chen (read his excellent post, Minimum Desirable Product) and Jason Cohen (read Releasing Early Is Not Always Good? Heresy!).  The other side is represented by posts like this one by Jeff Atwood: Version 1 Sucks, But Ship It Anyway.

While the debate is still ongoing, I’d like to write about a very specific related aspect, namely product development process (and those of us who would like to argue for fairly strict compliance to it).  Two recent blog posts address the topic of compliance directly, and I wanted to reference them and then write a quick response on why I think process is so important, especially in agile development.

The first is Seth Godin’s Dancing with entropy.  His rant on compliance actually inadvertently includes a pretty good description of what Product Managers do:

People are often paid to enforce compliance. The job is to ensure that everything is in its place, that errors are zero, that things are delivered on time and as expected. The random event is a problem, something to be feared and extinguished.

His main point seems to be that you should embrace the unknown, and “dance with it”:

Most people, though, the ones with great jobs, are in the business of dancing with entropy, not creating it. Take what comes, sort it, leverage it, improvise and make something worthwhile out of it.

I’m assuming he refers here to the definition of entropy as “a measure of the disorder or randomness in a closed system.” This is a great sentiment and we should all be able to deal with the unknown, but in practice, creating Ordo ab Chao during development can only happen effectively with proper product process behind it.  You can’t dance with entropy without bug tracking, if you catch my drift.

The second is a post by Aslam Khan entitled Forced compliance is an obstruction to discipline.  I respect him a lot for his forceful call for self-discipline in development, and I don’t doubt his sincerity at all when he writes:

Surely, we have learned enough from spectacular failures that governance does not give people an opportunity to exercise self discipline. When you give a person a chance to develop personal discipline, then forced compliance is unnecessary. With forced compliance, we force people into ignoring their own discipline because the system will “sort” it out for you. It breeds an attitude of “the system failed me and it’s not my fault”.

This is an ideal situation, and I agree with Aslam that personal responsibility is an essential quality for any developer — and PM, and designer, and human being, for that matter.  But personal responsibility is just not going to get you all the way there.  And by there I mean a product that is successful in the eyes of the company and its users.  I’m not arguing for the perfect product — there is no such thing.  But there is such a thing as desirable products that work the way they are supposed to and meet customer needs.  And for that, you need more than personal responsibility.

It is a mistake to think that process/compliance slows down development or inhibits innovation.  Compliance puts boundaries around what is within scope, and allows you to know when the product you’re working on is ready to launch.  Compliance also doesn’t mean that you don’t trust your team, or that you think people aren’t capable of working on their own.  It’s not about keeping tabs on people, it’s about making sure the product doesn’t get out of control.

By compliance I don’t mean an inability to roll with the punches and remain agile, but that a certain degree of process is needed.  In an earlier post on the software product development lifecycle I go into more detail on what I believe is a good process for product development.  I also discuss three outcomes recommended by Pragmatic Marketing: Requirements, Functional Specifications, and Technical Specifications.  I do believe we need this level of process, and compliance to it, to build great product.  We should embrace it, not fight it.  You know, dance with it.

As a Product Manager, I understand the Minimum Viable Product (MVP) concept, decisions to de-scope rather than delay, etc.  But too often MVP’s go out into the wild missing that all-important middle “V”, so you end up with, well, minimum products.

An example I came across recently is the sign-in process on Comcast.com.  First, a little background.  Comcast recently deployed a product they call mySIGN-IN.  According to their FAQ page:

mySIGN-IN is a unified sign-in system that lets you use your existing email address and password to access participating Comcast sites. When you sign in to any participating Comcast site, you’ll be conveniently signed in to the other sites that you use.

That all seems well and good, but the actual sign-in experience shows what happens when features go out without proper integration.  The sign-in process now happens on two separate pages:

Step 1: Enter email address

Step 2: Enter password

Two things struck me immediately about this experience:

• There is no reason to split the sign-in process into two screens.
• The visual design of the two pages are completely different.

Wanting to give Comcast the benefit of the doubt, I started looking into this a little more (because, you know, what else am I going to do on a Sunday afternoon apart from listening to Amos Lee on vinyl).  I thought that maybe this was an acquisition, and they are just taking some time on the integration.  But no, as far as I can tell, mySIGN-IN is not an acquisition — it is an internally developed product.  So I think this is what happened:

• A separate Comcast division designed and developed the mySIGN-IN feature
• The different Comcast properties started implementing the feature onto their sign-in pages
• Due to technical reasons, the pages had to be split for Comcast.com
• There was no UX oversight to ensure design consistency (or no resources available to make necessary changes)

Now, it does appear that someone at Comcast realized that this is not an ideal experience, and decided that explaining the changes to users is in order.  It’s a noble idea, but as we know, most users don’t read anything that’s not inside or next to a text box.  Either way, here are some of the tool tips that were added:

That first tool tip really bugs me:

Due to some recent security improvements, we now require you to enter your user name and password in two separate steps.

That just doesn’t seem right to me.  Due to “security improvements”?  I may be missing something from a security perspective, but I just don’t see why the sign-in information can’t be passed through securely without splitting up the pages.

What this means for product managers

I don’t mean to pick on Comcast.  This type of thing is very common, and I’m sure I’ve made similar decisions in the past that results in a user experience that’s not ideal.  But I do think this example can teach us a few things about product management:

1. Product owners (those responsible for individual features) need Product Strategists to ensure UX consistency (see this article from Pragmatic Marketing about different Product Management roles).  mySIGN-IN was clearly design in a vacuum, which could have been ok if there was someone who made sure the user experience stayed consistent across properties.
2. Don’t leave out the “V” in the MVP.  I believe that Comcast didn’t launch a minimum viable product.  Splitting the login pages into two screens is unnecessary and confusing to users.  The MVP might be an incomplete product, but it should never feel incomplete to users.  Users shouldn’t be able to notice that something is missing.  There is clearly something missing here.
3. Tool tips won’t solve everything.  If I had a penny for every time I heard the phrase “We’ll just add some content to explain that to users…”  As a general rule, if you need a tool tip which links to an FAQ page to explain something to users, your design is probably not intuitive enough.  It cannot be stressed enough that users really don’t pay attention to a lot of text.  The average user sees a form field, and starts typing.  Your user experience should support that behavior, not try to change it.

I have no doubt that Comcast had the best of intentions here, and that mySIGN-in is probably a cool feature.  But without proper product management, even inherently cool features can become frustrating user experiences.  Let’s be the users’ champions when it comes to launching new features.

Introduction

I’ve seen a lot of product development processes over the years, and as with most things, it’s important to take what works for your organization, and leave what doesn’t work.  These processes go by different names, mainly various combinations of the words Product Development Lifecycle (PLC or PDLC).  There are also a common thread through most product development models, and this article assumes that the reader has a basic understanding of the general five steps of product development:

Great work has been done on fine-tuning the details of the PDLC, but it has always bothered me that there is not one universal model for software product development that fits two main criteria:

• Specific enough so that it gives real and practical guidance for product managers and organizations on how to design and develop good product.
• General enough so that it can be applied to all different types of software development methodologies (Agile, Waterfall, Spiral, etc.)

And that is what I set out to do in this article.

A universal model for software product development - first draft

So, here is what I have come up with so far.  I hope that this initial attempt at a universal model for software product development can generate some discussion on what works and what doesn’t, what’s missing, how it can be refined, etc.  Below the illustration I go into more detail on each aspect of the model (click to enlarge).

There are a few assumptions that are important to note about this model:

• Regardless of the development methodology, representatives from Product, Marketing, Business, Design, and Engineering should be involved to some extent in each step, all the way to the writing of the technical specifications, after which it largely becomes an Engineering and Product effort.
• Having said that, it is important for one person to own this process (i.e. be accountable for its success) from start to finish, and that person should be the Product Manager.  A good product manager is not a dictator.  He/she is a facilitator between all the different stakeholders in a product, and the really good ones are able to get through this model on time and on budget, every time and with as much consensus between groups as possible.
• This model is designed to work for any organizational structure, project size, and timeline.  If the project is large, more time can be spent on each step.  If the project has a tight timeline, it doesn’t mean that you will skip the “Iterate” part of “Design + Iterate.”  It just means that you will spend less time on it (more on that later).
• I highly recommend reading Adam Nash’s post entitled “Guide to Product Planning: Three Feature Buckets.”  He recommends that every feature release should have a combination of what he calls Customer requests, Metrics movers, and Customer delight.  I am in total agreement with him, and this is an important underlying assumption for this model to work effectively.

Detailed discussion of the different aspects of the model

Let me start by saying it is possible to write a separate blog post about each of the bullet points below.  My goal here is to be general and make one or two points about each aspect.  If there is interest I could expand further on any of the concepts in the model.  So with that said, let’s look at some definitions and implications of the model:

• The starting point - identifying needs.  At the beginning of any project (new or iterative), it is important to gather and synthesize input from three different sources:
  • User needs.  Everyone needs to have a good understand of the market, the target segments, and their behaviors and attitudes.  There’s not enough room to go into detail here, but it is important to look at four sources of user input: market research (segmentation, etc.), user experience research (usability studies, ethnographic explorations), site analytics (behavioral analysis), and customer support (call transcripts, interviews of CS reps, etc.).  Having this common understanding allows the organization to build products that matter to users.
  • Business needs.  User experience practitioners too often neglect the fact that well, your site has to make money!  Revenue goals are not a good excuse for bad design, and that attainable revenue goals are essential to push the organization to design good product.
  • Technology needs.  Engineering needs to be at the table from the start.  They know the limitations of the product, they know what needs to be fixed, they know where the architecture can improve.  Their up-front input is essential in good product development.
• Problem statement (Requirements).  I am indebted to Pragmatic Marketing, particularly a post entitled “On Reqs and Specs: The Roles and Behaviors for Effective Product Definition,” for the definitions I use for the three different documentation outcomes in this model: Requirements, Functional specifications, and Technical specifications.  The first outcome from the discussion and synthesis of needs is a common understanding of the problem statement you are trying to address, which takes the form of Requirements.   A requirement is simply a short statement of the problem, and Pragmatic Marketing recommends the following format:  “Our preference is the Requirements That Work format: [Persona] has [problem] with [frequency]. It forces product managers to explore the problem, not the solution, and helps the design team understand the context of the problem.”
• Diverging and converging design thinking. Once the problem has been defined and agreed upon, the team starts thinking about solutions.  There are three important aspects of this phase, which is often called Product Discovery:
  • Start with blue sky ideation (divergent thinking).  At this point, don’t limit solutions by what is technically or otherwise feasible.  Spend time dreaming about the product - this is where innovation happens!
  • Relentlessly prioritize (convergent thinking).  This is the part of the process where nonsensical ideas are thrown out, and the team consolidates around a few possible solutions to the problem that can be further explored.  Remember: there is no commitment to implementation or specific designs yet at this phase.
  • Apply the technology filter only after the ideation phase. I wanted to explicitly call out the roll of Engineering during the solution discovery phase.  It is a mistake to bring Engineering in too late in the process.  There is a very important technology filter that needs to be applied during prioritization.  What is technically feasible?  If something is currently not feasible, what would it cost to build the right architecture?  Those early inputs can save a lot of headache down the road.
• Functional specifications. The second output document from this model are the Functional specifications, which Joel Spolsky defines as follows: “A functional specification describes how a product will work entirely from the user’s perspective. It doesn’t care how the thing is implemented. It talks about features. It specifies screens, menus, dialogs, and so on.” Note that we’re not talking about technical implementation yet, that comes later.
• Design and Iterate.  Everyone designs a product, but it is sad to see that when time/budget gets tight, iterating on it before it goes live is often the first part of the process to fly out the window.  It cannot be overstated how important it is to prototype and test your designs before they go live.  And not having time is really no excuse.  If you have no time, make a paper prototype and test it with three of your friends over coffee in the evening.  You’d be surprised how much value this can add.  Boxes and Arrows has a great article on prototyping and how to integrate it with your design process that’s well worth the read.
• Technical specifications. Only once you have a set of Functional specifications and a Prototype of some form (even if it is very low fidelity), it is time to work on implementation.  Quoting Joel Spolsky again, “A technical specification describes the internal implementation of the program. It talks about data structures, relational database models, choice of programming languages and tools, algorithms, etc.”
• Build and launch. If you’ve done the upfront work, this could actually be the easy part.  You have a set of requirements, a prototype, and a detailed set of specifications to work with, so now it’s time for the Engineers to work their magic and build the product.
• Assess.  The assessment phase is extremely important and often overlooked.  It is important to define your measures of success upfront, and then follow up to see if you’ve met those goals.  How do users respond to the product?  Are we meeting revenue/engagement goals?  Are there bugs that need to be fixed?  What can we learn from how users interact with the product to give us ideas for new products?  I’m also an advocate for using the same four sources of input we discussed earlier (market research, user experience research, site analytics, and customer support), as opposed to relying on only one methodology, like a 3-week A/B test.  More on the dangers of that in one of my earlier posts.

Implications and final thoughts

I think this is a decent first attempt at a universal model for product development that can be applied to any timeline or organization type, but it is far from perfect.  I hope that the product management community can come together and refine this so that we can end up with a credible, relevant, and useful model for building great product.

Eventually, I’d like us to build out this model so that it is more easily adjustable based on certain constraints that might exisit within a project, such as budget, time, development methodology, and team size.  But let’s see if this one passes the smell test first…