How to Get Real in Corporate Development, Part VI

This is the sixth part of a series of essays on how to leverage the concepts of Agile software product development from Getting Real from 37signals in a corporate development organization. Part I introduces the concepts of Getting Real, part II looks at the idea of building less, part III is on focusing on one idea, part IV is on getting something functional out quickly and part V talks about focusing on how your users will use the application.

Now it's time to look at:

Focus on fulfilling business stories, not big specification documents.

In my 20+ years of technology experience, I have seen this as being the biggest and most pervasive problem. And I understand that it comes from a very valid perspective from the engineering community.

Engineers can not easily manage huge amounts of change to requirements. Imagine building a bridge if the length of the span changes weekly, the material under the footings shift regularly and the sponsor wants the bridge in steel; no, titanium; no, wood; no, aluminum; no, steel -- you get the point. Therefore, engineers seek to define the requirements and get agreement and sign-off on those documents so they can build something once. Plus, we all know that change gets more expensive as a project progresses, especially if you have a waterfall or spiral approach. All that inflexible foundation work is very expensive to change. (Another reason to stay light and agile!)

Because of the cost of constant change, engineers push to define requirements up front so that they know what to build and where to start. They require definitions, use cases, scenarios, storyboards, and so forth. From this collected material, they define the grand scheme, break it down into delivery phases and get agreement and sign-off. Again, they want to build something once.

The flaw with this approach is that the requirements cannot be entirely known in advance. Therefore, just as soon as the project starts, the huge requirements specification is out of date. I once worked on a project with over one thousand distinct requirements. Because we were inventing new science and technology while producing a commercial product, the requirements churn was huge. We touched every single requirement dozens of times; the requirements churn topped 1000%!! That's like writing over 10,000 requirements! It was nuts!

Here is the fix: Focus on business stories. Start with the most important story. It works like this.

The business problem is, "We have to generate an inventory spreadsheet daily by running a report in our inventory management software (IMS), copying the date and transforming it into Excel, then cleaning up the data by re-arranging the columns and saving it as a semi-colon delimited file so it can be emailed to the web services group so they can update the inventory counts on the website. Errors and delays in the process can mean displaying products as in-stock when they are currently back-ordered, which annoys customers."

The business story becomes, "We want to automate the daily inventory reporting from our IMS to our web server to increase accuracy, decrease information turn around time, and free business resources for other work."

I can immediately see a number of ways to do this, from using whatever automation exists within the IMS to generate and send that report, or accessing the IMS database directly with a custom report, or using the IMS database programmatic API to write an automated application to pull the data and update the web database, or to make the web database read its data from the IMS database live, or on a daily batch bases, or exposing a web service so the data can be pushed into the web database. I bet you have a few more options.

The take away is that solving the technical problem isn't usually the problem. The problem is solving the correct business problem. Getting bogged down with a huge requirements document doesn't make solving today's problem go any faster and doesn't produce a solution to today's problem any faster.

So, how would I apply this advice to that huge 1000% churn project? Well, the biggest constraint was that we had to produce a commercially shippable product. A goal was to create a single architecture that could be leveraged along the future product line. However, since we were creating new technology and a new command and control system, we set the bar too high.

The immediate business story was to operate the machine and provide a sufficiently flexible control system that would allow for the scientific invention to continue without requiring huge software re-writes. Today, I would drop the goal that we create an architecture that could handle future demands. The project was already very challenging without that goal and we ended up pulling out all the infrastructure that was built to handle that goal anyway, just to get the first product to ship.

We made the classic mistake of solving tomorrow's problem before solving today's problem. You can avoid that mistake by focusing on the business stories that you have today and not creating that huge, over-arching requirements document that will doubtlessly saddle you to a very sizable ball and chain.

How to Get Real in Corporate Development, Part V

This is the fifth part of a series of essays on how to leverage the concepts of Agile software product development from Getting Real from 37signals in a corporate development organization. Part I introduces the concepts of Getting Real, part II looks at the idea of building less, part III was on focusing on one idea and part IV was on getting something functional out quickly.

In this essay we look at:

Start with the UI design and focus on how your users will use your application.

Lots of experienced engineers like to start with the UI. A new project brings a geyser of ideas and concepts that make the fingers itch to start writing code. So, mockups, prototypes and proofs of concepts are often the first things to come out.

Good! Almost.

Don't let your engineers close themselves in a room for the four weeks that they have and create something they love. The rest of the sentence is the key -- "focus on ... your users ..."

In "Getting Real", the folks at 37signals assume they are writing an appliation for the outside to use. They don't have an opportunity to sit with their most important users when creating something new. But you do! This is where the corporate environment make Getting Real better than the original. You're making software for your business, you and your users are the domain experts. You don't need to go outside. Lucky you!

Get your engineering team (2 really good engineers and a kick-ass business analyst) in the same room as the key stakeholders -- the folks who will use this new system. Understand the business problem (Focus on One Idea) by talking to the users and examining the problem they need solved.

Have the team work through what they need to do. What tasks are grouped to gether logically? What actions are done most of the time? What actions are done only a small fraction of the time? Make the application fix the problem elegantly. That way, the team has to Build Less and will be able to Get Something Functional Deployed Quickly.

Start light. Whiteboard and sketches. Wireframes and light-HTML. Test the process. Can the users do their important tasks quickly and easily? Can they see how they get to the additional features that they don't use every day?

Put the most important information right in the middle. Make sure that new state, the populated state and the error state are considered. Ensure the engineers make the application behave appropriately when it encounters something unexpected. Leave out what doesn't belong to do the task (who cares if it's a "standard" menu item?). Put in everything important. Leave out everything else.

Match and support what the users need to do, then go and make it happen. Start with the UI. Not the UI and the database, just the UI. Not the UI and the object model, just the UI.

The engineers will have a clearer idea of what's important. They will have proven the work flow that they are about to implement. The users will have increased confidence that what will be produced will really help them.

Can you just imagine the response when the first version comes out a few weeks later? Hey, please write and let me know! I don't want to do this in a vacuum!

Thanks again for reading! In the next essay, we'll talk about how to use business stories.

How to Get Real in Corporate Development, Part IV

This is the fourth part of a series of essays on how to leverage the concepts of Agile software product development from Getting Real from 37signals in a corporate development organization. Part I introduces the concepts of Getting Real, part II looks at the idea of building less and part III was on focusing on one idea.

Next, we talk about structuring the project to quickly produce working code. So here it is:

Get something functional and usable deployed quickly. Plan on your next release right away. Make a choice and go with it.

Constraints are what drive a project. If you had unlimited time and money, you would probably never produce anything, as ironic as that may sound. You need limits to focus you on getting something done. My triathlon training buddy and I like to say that we "train to race and race to train" because without the race date, it's too easy to sleep in instead of hitting the pool at 5:00 AM. Constraints drive us.

So, pick one of your projects and give it to a small group of good engineers. Tell them they have four weeks to produce the first version that the business can use, but then they'll have four more weeks to produce the next release. And close the door.

They will focus on building less and implementing one idea. It's all that they'll have time for. Meanwhile, let the business know that the first iteration will be ready for use in four weeks and that the engineers will need their feedback to produce the second iteration.

Your job is to get out of the way and make sure the engineers have the tools, access and permissions they need to do their work. Herein lies additional opportunity.

Perhaps there are procedure and process documents in your organization. Perhaps there is a PMO and a review committee. Perhaps you have strict regression testing requirements for deployments. Perhaps, under normal circumstances it would take your small, Agile group of engineers four weeks just to get permission to connect to the database they need to fulfill this project.

Your opportunity is to fix this. Yes, security and access control is critically important. But, we're in the 21st Century, aren't we? Network directories with access control list are mature technologies and are probably in your organization. Are your Oracle databases set up to take advantage of your LDAP infrastructure? They should be. And no one better exists than you to make it happen.

Your organization should have four environments:

• Development -- open and flexible for the developers to do anything. Developers should work in both Debug and Non-Debug environments. Don't accept "Well, it worked on my machine."
• Test -- mirrors production, but allows developers to see everything in the system.
• Staging -- mirrors production as closely as possible
• Production -- full security and access controls.

Using virtualization, farms, and similar techniques can keep this from being a horrible amount of overhead. The key is that you need to unlock your most productive engineers. Now is a good time to note that not all of your engineers are your most productive ones. Make sure your less productive engineers are fully supporting your most productive ones. There are opportunities for training and mentoring, which build employee satisfaction and loyalty, but let's get back to getting functional software out.

How many times have you already read that a skilled and senior engineer is many times -- 10 times, 15 times, 20 times -- more productive than a junior engineer? So, we don't need to say it again. Nope. Not going to say it. Na-uh.

So then, just how will this work? Well, let's start off by looking at the typical process. The business has an urgent need. Something like, "they spend a huge amount of time running end of month reports and small errors in the data cause regular heroics."

In the typical process they fill out an Application Enhancement Request or New Application Request or some such like that. This gets reviewed at the next Application Review Committee meeting and goes back to the requester for more details. Two weeks go by for the out and back trip and the ARC approves the request. The next week a project manager and business analyst are assigned to it. They take two weeks to gather requirements, another week to create a Statement of Work and one more to have that approved by the stakeholders. The following week, a project team is assembled while the analyst writes the Functional Specification. The stakeholders don't even bother reading that.

We're up to, um, nine weeks. The team takes two months to write the application, three weeks to test it, one week to slot it into deployment and, lo and behold! More than five (5!!) months later, the application is first released. The users try it and file a new Application Enhancement Request to get it to do all the things that they need and eliminate the stupid things that crept into the application. Time to happy users: 9 months.

Here's how we want it to run:

First, you've addressed the infrastructure, you have the governance in place to enable rapid development and you've now paired your best engineers with the business users we just talked about. They meet for one day and use up another afternoon or two. In four weeks the first release is out and in use. In four more weeks the next version comes out and fixes the big problems with the first release and adds a few more features. One more four week period and the business has something that really works for them. Time to happy users: 3 months.

Even if you give this team another three iterations -- that would be a total of six (6!) releases, it would still be 66% of the duration of the Same Old Way, which would have produced 2 releases. Which application do you think would be better? The one that had six tight, focused releases, or the other one? There is no doubt in my mind.

You need to have really great developers to do this. But then again, nothing outstanding was built by mediocre engineers. You need an infrastructure that enables these really great engineers. You still need to have proper governance, SOPs, checks and balances to put software into production, but you can get the work done much, much faster by Getting Real. And this will generate real value for your company.

Thanks again for reading! In the next essay, we'll look at starting with the UI.

How to Get Real in Corporate Development, Part III

This is the third part of an essay on how the concepts of Getting Real from 37signals can benefit development groups in corporate environments. Part I introduces the concepts of Getting Real and part II looks at the idea of building less. To build less, you need to select one problem to solve and focus just on that. Part I introduced this, so let's continue to look at that aspect.

Focus on one idea. Start with the big problem, build the large scale functionality and don’t sweat the details.

One challenge every development effort has is where to stop. That is, where to define the edge of the application. Otherwise stated as, "how far out from the core idea is it reasonable to extend?" For example, should the document handling system not only import PDF's, but generate PDF's and fax them?

One helpful concept is the constraint of time and budget. However, it is not uncommon in corporate development shops to have projects loose the continuity of effort that makes a strict delivery time or budget tracking approach overly challenging. Here is where having one focus pays of immensely.

The thinking is: We are going to solve only the problem at hand (Today's Problem). Building less gets us a solution more quickly. Focusing on the problem helps us meet the goal of solving only the problem at hand.

Engineers with are much easier to keep focused and on-task when they have a delivery due in only a few weeks. Assigning a single, short-term purpose accomplishes this. Part of the standard challenge in corporate development shops is that the an engineer wears many hats as she maintains existing applications, develops one or more concurrent projects, and concurrently designs and plans future applications.

Switching between different types of tasks is a known productivity killer. The well-known blog by Joel on Software lays out the trouble with human task switching. You know it yourself, having your concentrated thought process interrupted is, literally, disruptive. For your team, this means that they need quite, private work spaces, few meetings during sprints, and very long periods of uninterrupted time. It also means you need to keep their plates clear of other tasks.

When you do this, your engineers will be able to stay focused on delivering that one idea.

"Hmmm, good," you say, "but what is the correct one idea?" Good question. After all, "solve global poverty" is one idea, but it's obviously not at the right level.

You're looking for an idea that represents a specific business pain point with a solution that can be produced by a small team in a few quick iterations. Since your team of three engineers can't bang out a solution to global poverty in a few three-week sprints, it's not at the right level. (But you already knew that -- this was an illustration :-)

Let's try some on for size. "Create a portal that allows secure transmission of documents from customers to service representatives." Or how about, "Replace a key paper form with an internal website." Here's what each of these have going for them:

• Each of these have a good change of being produced rapidly in only a few iterations.
• They both address only one problem.
• They require one small application to successfully meet the business need
• They both are probably very well understood by stakeholders and engineers.

Given all this, there is very likely little risk of implementing the wrong software. Even if the end product doesn't work out completely, you have only invested a small amount of time and effort and you're team has more clearly illustrated the business need.

Are you thinking that you don't have any small, simple problems to solve? Are you thinking that you need complex applications to solve complex business problems? Are you thinking that there isn't any opportunity to do something small and elegant like this in your shop?

If you have any of these thoughts, or thoughts similar to them, please try an experiment. Find a key stakeholder at the line level. Perhaps a manager of customer service, or a project manager who executes key services repeatedly. Take them to lunch and ask them about the most challenging aspects of their work and the work their team or group does.

You will probably learn some things you didn't know. And some of what you learn could very well fall right into this camp of creating high-value for the business with a light, flexible, low-risk and low-cost development approach.

The next part is to work with wide brushes and big strokes. You're not looking for a whiz-bang gizmo that does everything. Get the big pieces right first. Now that you know about some business pain points (if you already knew some or knew the ones you talked about over that lunch, then kudos for you!), you're looking to address just that need. Nothing else right now, just that one need.

Yes, the fund accounting deals with mutual funds, 401(k)'s of mutual funds, annuities, closed-end funds, etc. But the bulk of the work is mutual funds. Or the bulk of the time is 401(k)'s. Or the bulk of the revenue is generated by something else. It's up to you to figure out, with your key stakeholders, what the most valuable problem to solve will be, then it's up to you to focus on that one factor.

The mandate you give your team is to fix just that one piece, make it better for the business and don't worry about the details. You will re-work and re-engineer as you dig down into the next set of priorities on upcoming iterations. But you will be providing a high-value solution in very short order, and that is worth more to the business in the long run.

Thanks for staying with me as we continue exploring the approach of Getting Real in your corporate development shop.

How to Get Real in Corporate Development, Part II

This is the second part of an essay on how the concepts of Getting Real from 37signals can benefit development groups in corporate environments. Exploring this mash-up is worthwhile because at first glance, there seems to be very little in common between the web-application, small-team, product bootstrap philosophy in Getting Real and the realities of corporate development teams. These realities include governance, oversight, processes, controlled systems and similar best practices. But pull the covers back a bit and enough similarities appear to make for a compelling argument. Let's dive right in and take a closer look at the key concepts from the first essay.

Build less. Build smaller applications with only the most important features and delivery it quickly.

This is sage advice because the corporate development life cycle is typically beset with serious birthing pains. Life cycles are heavy with process, stages, gate reviews and sign-offs. The corporate process inevitably includes requirements gathering and documentation, which involve meetings, drawings, documents and reviews. The requirements themselves transform from stakeholder statements to business requirements to technical requirements to design documents. After all that, there is finally the build, test, deploy, train, support and maintain functions. All to get one release to the business users.

Some problems with this model is that it takes too darn long and is too darn expensive. Half a year can pass filled with stakeholder interviews, document drafts, reviews, modifications and so forth that will ultimately produce a few dozen pages of specifications and diagrams. One team of stakeholders, business analysis and engineers can easily spend multiple person months or even a person year (or years) producing 60 pages. If you have a blended team salary rate of $90K, then each page costs $1,500. And you haven't built anything yet!

"No" you might be answering resolutely right now, "but we know know what to build! And we have a plan to build it."

True. I've worked this way too and I know that it helps to reduce the risk of development in the long run. You can plan for a three-phase development effort, get the budget lined up and all that. However, please consider an alternative.

Your team knew -- on day one -- what was the most important functionality needed. You, and they, don't need 6o expensive pages for that. Here's how it would work for you when you Get Real.

Two good engineers and a business analyst -- your development team -- meet with the key stakeholders. The stakeholders are asked to identify their top problems within the problem space. Then they have to choose only one. The top problem. Your development team ask enough questions to fully understand that problem and how it relates to the other top problems.

Then, they go away and produce something small to fix that top problem and only that top problem. This takes three weeks. After all, they are focused on only one key important problem.

Next, the key stakeholders begin to use the new application. After one week, the team reconvenes and the development team learns what works, what doesn't and what the next most important problem to solve is.

At this point, you've spent a tiny fraction of the expense and effort of that functional specification we taked about earlier and you have an application that, hopefully, solves an immediate business problem. If it doesn't, it has shone a big, bright light on that problem. How much longer do you think it will really take your development team to get it right? One more iteration? Two? Fine; because at that point three months will have gone by and you will have a demonstrable ROI. Compare that to a functional spec that takes six to nine months to write. You are seriously ahead of the curve.

OK, another valid concern is that when your development team learns about the next problem they will have to throw away a lot of what they've done. And they might. This is why we focus on solving one problem within the context of the larger scope. However, it is critical to solve only one problem at a time. Fix the problem you have today, not the problem you anticipate having tomorrow.

The way to do this is to build only what you need to fix that problem. Build less. What is the smallest, most elegant solution to the business problem?

Keep in mind that the business problem might not be the problem the users report. They may be unhappy with emailing spreadsheets around and want the population, generation and transmission automated. However, what they really need is a way to exchange and store information centrally instead of relying on spreadsheets.

Thanks for reading. We will continue to peel back this onion in the next essay on Getting Real in your corporate development shop.

Using Getting Real Concepts in the Corporate Office

The talented and intelligent folks at 37signals have created some great applications. As major contributors to Ruby on Rails, they also have been fundamental in building and leading a revolution in rapidly developed, high quality web applications. 37signals is successful because they think creatively about the problem that they are trying to solve. Fortunately for all of us, part of that thinking is that they should be open and transparent with many aspects of their process and business. Therefore, they often preach about the practices that have helped them attain success.

Anyone can read their preachings online. For free! It's a great concept, and one that is often encouraged by industry leaders -- think Seth Godin for one.

You can also purchase a high-quality bound copy of their book “Getting Real” from Lulu.com. I have because I like being able to read when not in front of the computer. It’s all laid out in their book (the exact same copy in the web pages, downloadable PDF or book) – their philosophical approach to clients, development, hiring, customer service, and so on.

When I became aware of 37signals , I was developing Ruby on Rails web applications. Because I was creating web apps, which is clearly the focus of the book and philosophy, I found myself agreeing with just about everything they were saying. And hey, I’m a software development veteran.

I’ve done this for years and years and have focused extensively on managing complex projects to successful deliveries. I’ve been through waterfall, spiral, iterative, agile, ad hoc, chaotic, random and panic-driven development models. I agreed with what they were saying because it makes sense and I was able to make it work successfully on my projects without any pain or difficult transitions. There aren’t many “new” development philosophies about which that can be said! For light, flexibile web apps, “Getting Real” made total sense and, more importantly, it worked.

But what about corporate environments with ongoing development efforts? These shops have a different set of starting points and different base assumptions. What if you aren’t developing a web app? What if you aren’t focused on revenue generation with your app? What if your users are waiting for their application and have expectations about how it will help them?

Can your corporate development efforts also Get Real? Yes, I believe that they can. let's look at the components of Getting Real that will help your corporate development teams use the principles from Getting Real to improve productivity and stakeholder satisfaction levels.

Let’s start with some of the key concepts of Getting Real that are directly beneficial for all development efforts. (Links are to the essays on those concepts)

1. Build less. Build smaller applications with only the most important features and deliver it quickly.
2. Focus on one idea. Start with the big problem, build the large scale functionality and don’t sweat the details.
3. Get something functional and useable deployed quickly. Plan on your next release right away. Make a choice and go with it.
4. Start with the UI design and focus on how your users will use your application.
5. Focus on fulfilling business stories, not big specification documents.
6. Keep your developers on the front line of support
7. Be willing to radically change the application to make it better. Resist the urge to make one monolithic tool to solve everyone’s problems at once.

Notice that these nuggets are completely environment, tool, and technology agnostic. There are some radical ideas that will doubtlessly shake up the “way things are done”, but these are the right ideas to grab onto and the right changes to make.

Fortunately, there are some components of Getting Real that an internal corporate development group can safely ignore right off the bat. For example, you’re probably not looking to generate revenue with something like an internal workflow enhancement tool. Not that you can ignore development costs or the value proposition of the development effort, but at least your users won’t be facing the prospect of paying a monthly fee. (Although, there may be something here….)

You can safely ignore the need to market and promote your application extensively. Please note the qualifier. The new whiz-bang tool you’ve developed for Operations is straight sunk costs if end users aren’t using it. Therefore, they do need to know about it and they should be excited about its arrival and feature set. But that should come from good communications and interactive product development and not from promotional marketing campaigns. Trumpeting successes is always allowed, however, so some allowance is made, but we’re not talking at all about the same degree of importance of marketing discussed in the book.

Most importantly, as you – the development lead, manager, director, VP, CTO, Whatever – read Getting Real, you can insert your favorite technology du jour whenever the book talks about web applications. The thrust of web apps in Getting Real is their rapid deployment and instant accessibility to customers. No CD burning, no distribution efforts, no retail operations, etc.

But let’s face it, how long does it really take to deploy a new version of an internally developed application in your shop whether it was written in C++, Java, Lotus Domino, C#, .NET or Ruby on Rails? If you’re thinking “weeks”, then you’ve got another problem, don’t you? You can quickly push out new applications through automated corporate update mechanisms, internal web sites and internal installers with the exact same degree of responsiveness that is the base assumption in the book So don’t sweat it that you’re not making a web app. The underlying philosophies in “Getting Real” remain pertinent, applicable and valid to you and can revolutionize your development centers.

The next essay will look at those seven take-away concepts in greater detail and will focus on how you can leverage these concepts to make high quality software faster.

Mysteries of On-Time & On-Budget revealed

Yes, true believers, now is the time of your enlightenment. For years have you stumbled in the dark, arms raised, hands reaching, gingerly feeling for obstacles. You have relied upon truisms and common sense to get you to your goal, knowing that if you only stay on the straight and narrow, you would succeed.

I, too, once believed the same. I, too, used to tout that the way to success was a straight and narrow path, fraught with danger and risk. "DO NOT STRAY FROM THE PATH!" I used to preach, "for the number of roads to ruin are immeasurable, but that way to enlightenment is straight."

Horse hooey and poppycock.

Now hear this: You can build successful products on-time and on-budget over and over again. Here is the secret: constraint. Yes, if you have the discipline to constrain yourself, then you will experience the joy of on-time, on-budget.

The way it used to be

Here is what we all used to do. Tell me if this doesn't sound familiar.

Identify functionality (often in a room full of executive and managers). Document and define functionality. Design application -- user interface, object model, database schema. Finely define functionality for each component, estimate the work involved, identify risks and opportunities, weight the estimates with the risk category and produce a schedule. Assign costs to the schedule and develop a budget. Add padding. Review the preliminary specification (which hardly anyone would read), the preliminary schedule (which would invariably be pulled in for "business reasons"), the preliminary budget (which would be reduced). Revise, regurgitate. Stamp with seal of approval.

Begin work. If you were good, you would track progress against estimates. Within the first 25% of the project you were either on time, or you were slipping. If you were good, you would fix the causes that were making things slip, but for most of the projects, most of the time, you simply raised the flag "We are slipping." No one paid any attention until the last 25% of the project, desperately trying to fix something in the last 10%. Herculean efforts, late nights, long weeks, weekends, etc. You finished.

Congratulations, you had 85% of the functionality, were 20% over budget and 15% over deadline. Or something not too far from that.

You had a party, celebrated the success and kicked off the next project the next morning. After all, you had sufficient headroom and padding to ensure that even with this scheduling and budgeting failure, the product worked.

In reality, the majority of efforts did not produce a successfully released product. This is still true today.

The way it will be

Here is how you will change your life and be successful in producing remarkable products.

You will talk to your customers. Even if you are creating a brand new product for a new market that doesn't even exist yet, you will be selling it to someone. Find them. Talk to them. Call them. Ask leading questions. Listen. Ask and listen again and again.

This process will still produce a list of functionality. However, because you have gotten the pulse of real consumers who would pay real money for your product, you will know what is important to them.

Put the most important functionality at the top of prioritized list. Now figure out what is the least amount of work that it will take to produce the most important functionality. You are permitted to deliver only the top most item if necessary.

Now you may go ahead with your process. Design the user interface, object models and database schema. Break down each component and make work estimates, identify and assess risks and produce a weighted work effort. Apply costs to the work effort estimates to create a budget. Do not pad. Your weighted work effort already includes risk factors.

This is where you stop and take a breath. If the costs of producing only the most important functionality are greater than the market opportunity, then there is no justification for producing the product and you are done. Shelf the idea and go onto the next thing. You just saved yourself a huge bundle of effort and money.

However, if the cost/benefit equation is positive, then you know exactly what it will take to make a product with one tightly focused set of compelling functionality. Now it is time to begin your race.

Your purpose is to produce the most important piece of functionality first. Make it work to the exclusion of all else. You are in a race against time and dollars. Every day, whether you are using Gantt charts or Backlogs, you must make this assessment "Are we doing the right work to produce the most important functionality?"

Here is where you ability to constrain yourself and your team pays off. New feature requests? Put them in the parking lot. Changed functionality requests? Parking lot too. Your ability to focus your team to constrain their work will bring you success.

Plus, you will have noticed that you have a much, much shorter time line then you used to produce. The old way had you implementing all the identified functionality. Now you are implementing on the most important functionality. In my experience, my time lines went from six months to three weeks on average with this approach. Assuming only 4 weeks per month (it's really about 4.3 weeks per month), then I can do eight iterative cycles in the same six month period. EIGHT! That is a lot of opportunity for addition and improvement.

By the way, your team includes the executive staff, management staff, and line staff. It includes Marketing, Sales, Operations, Engineering, and Customer Support. After all, your company is the vessel and if there is a hole in the bow, the stern goes down too, so everyone is responsible for keeping things ship-shape. Keeping your entire team focused on accepting the constraints will keep everyone happy with the end results.

Here is the final key. You will STOP and deliver when the FIRST of these three things occurs:

1) You have completed the functionality you intended. OR
2) You have hit the milestone you identified. OR
3) You have spent the budget you identified.


"But, but, but" I hear you sputter, "But what if I hit the milestone and the work isn't done?"

How could that be? Didn't you identify the least amount that needed to be done? Was it really the absolute least amount? Didn't you design the components to fulfill only the least amount of functionality? Didn't you estimate the work and weight those estimates? Didn't you stay focused on delivering only the functionality identified? Didn't you resist the requests, demands and temptations of adding or changing functionality?

If you really did those things, then you really will hit one of those targets successfully.

What happens too often is that the design accounts for future expansion. Or the UI adds additional features that add complexity but are not required implement the most important functionality. Or the database incorporates infrastructure for expansion, growth, additional reporting. In summary, you failed to constrain the work to the most important tasks.

It is very easy to fall into those traps. Which is why company after company, product after product, program, project, etc. make these mistakes over and over. If you can avoid these mistakes, then you can lead your company into iterative, focused product development and enhancements that will keep your efforts prioritized by value to the company. Plus you will deliver on time and on budget.

Re-examining Assumptions

Last Friday I met with someone who surprised me in a way I've not been surprised in a long time. This experience has sat with me since then and is inspiring me to re-examine my assumption model.

You see, the meeting was a first conversation about a position in a company and, truth be told, I was very unsure about the prospects and viability of the company. It has been in existence for over a decade, has a good size staff, but, although a web company, did not have significant traffic and, although established, had significantly lower revenue (and higher percentage overhead) than I had expected and with which I am comfortable. In short, there were warning flags.

My assumptions were that the company was not fully executing on its potential, or that perhaps the competition caught up to it and surpassed it. So that is where I focused my pre-conversation research.

The person with whom I met on Friday impressed me. First, he wasted no time in spelling out that he expected significant growth and he laid out the core thinking to his expectations. He made sense and had a fresh perspective on the problem, which is that the company's traditional domain is no longer its current domain, or more accurately, its current growth opportunity domain. The company has to move from one focus -- let's say "newsletters and messaging for the on-line widget industry" is what the company believes is its current domain -- to a new focus -- let's call that "automated marketplace for connecting widget manufacturers to widget consumers" as its new domain. This person's thinking is revolutionary for the company.

Unfortunately for my "pre-screening interview", it was also revolutionary for me. I assumed that we would be talking about one thing -- the company's market position, brand, existing product line, and immediate growth strategy -- so I didn't scour the information I had sufficiently to anticipate where the conversation would go.

From my project and program management experience, I know that it is critical to identify and document the personal and project assumptions for efforts. One of my favorite books on risk management, "Risk Management, Tricks of the Trade for Project Managers" by Rita Mulcahy is a canon that embodies the assumption identification in the processes. I've used assumption identification to pull out critical risk factors in my product management work; it's been a huge differentiator that has helped me get past personalities and focus on functionality, opportunity and risks in new product development.

So I am more than chagrined that I slipped on this. That made me wonder if assumption examination is part of the professional zeitgeist. It doesn't seem to be. Looking around for conversations on how assumptions are recognized and incorporated into various processes, I found an article from EE Times Asia on Re-examing Assumptions, plenty on assumptions at the software engineering level, a little blurb on program risk management from PgMP by Paul Sanghera in Google Book Search, a news article on SEI from 2003. Much more on the engineering side than the business process side, in my opinion, although New Product Forecasting by Kenneth B. Kahn has a section on assumption management that caught my eye.

There is opportunity here. Seemingly there is need for some assumption evangelism -- how are you going to check into your working assumptions about the important things in your life? I know what I'm going do about it in mine.

Software Development Process and the Start Up

Start ups are great places, if you like that sort of thing (and I do). Small groups of individuals infused with the entrepreneurial spirit working intensely on their Next Big Idea is invigorating. Strong, smart people can make a huge difference, albeit sometimes with herculean efforts, but at some point (more on this later), you launch.

Then you go right back into it the next day.

Which will eventually burn you out.

But greed and excitement are wonderful things, so you muster your energy, take a deep breath and dive back in. The launches are satisfying. The acknowledgment from your peers and management are satisfying. The accolades, press releases, funding efforts, and the promise that you are contributing to the Next Big Idea are all satisfying. But you know that it can't continue forever; that at some point the company will need to cross over from Commando stage to Infantryman stage and then eventually to Policeman stage (use what ever stage names you prefer here).

So here's the question; What do you need in terms of process at each stage?

Let's work our way backwards. No one would be surprised to find a mature CMMI and ITIL led organization at the Policeman stage. Some degree of CMMI maturity would quite natural for a company at the Infantryman stage, say CMMI maturity level 2 or 3; repeatable and documented process, improvement processes and some feed back capability.

But what about Commando? What about start ups? Eventually the commandos will move on and the company will be taken over by Infantrymen, but that could take years. For how long will the Commandos be running on their own gumption?

Those who live by process know the value it brings; reduced flailing, more reliable delivery, lower defect rates, greater alignment to business objectives. However, there is the challenge of perception to overcome. Perception that process interferes with creativity, introduces bureaucracy, hinders agility and is too expensive. Especially within the start up environment, which is often Cowboy development. "We have smart people, we don't need all that process stuff"

Poppycock and balderdash.

This is a simple case of "enough." Just enough process to deliver effective products. Just enough framework so that everyone knows that stages. Just enough practices so that a repeatably effective cycle can be created. Just enough monitoring and feedback to that mistakes are not endlessly repeated. Just enough borders to ensure that goals are repeatedly redefined to the point of ineffective thrashing. The basic check list is short:

• Short, but effective cycles -- this allows for flexibility and redirection without throwing away effort.
  
• Clear deliverable at the end -- the thrill of victory is a strong motivator
• Clear success factors -- New features in this build? Then only new features. Bug fixes? Then only bug fixes. One new feature and three critical bugs? Fine; do only that. What is the least amount that you can do to be successful in solving todays problems.
• Blessing and direction from senior management -- no sponsor, no work. The stakeholders decide what is the most important thing for them to have.
  

It is quite possible to respond to the short-cycle real-time demands of a start up. After all, the start up is first an idea. That idea will be tested by your customers, who will then tell you what business you're in.

All that stated, you have product to deliver. There is time pressure, and although there are unending pressures to constantly change, tweak and improve your product, you simply HAVE to launch. You HAVE to get to a launch date and the product MUST be released. Never loose sight of that.

So then the next question is "How can you manage the exchange of endless pressure with the real-time need to deliver?"

This is the job of product management. Product management starts with industry and market knowledge, time to market and market opportunity, cost to develop and return on investment. The funnel of endless ideas must be quickly and efficiently evaluated by a capable product manager. The value of the idea needs to be quantified without romanticism. The cherry picking becomes much easier at this point.

In summary, enough software process in the start up will produce superior products more effectively than ad hoc or heavy handed models. Focusing the development work on valuable efforts comes for successfully vetting the opportunities and defining the critical success factors.