Not to be overly simplistic, but there are three basic perspectives of web development:

• Usability, or user experience.  In its broadest definition, this is a measure of how good the web app is to the user; how much value it creates for them.  In a more specific sense it reflects a stack of best practices (and very, very occasionally innovations) that add up to the user experience on the site.
• Business value.  In the broadest sense this is “what the web app is doing for the people who pay its bills”.  This can be interpreted as monetization (via ads, conversion etc), or simply controlling the budget and schedule of the development project.
• Feasibility:  Often taken as a technical subject, it its broadest sense, feasibility simply describes how much effort goes into making something happen.

The catch is, to truly make something successful, both from the perspectives of  project management (launch on time, on budget) and product management (build something that is successful in the real world), you need to keep your eye on the ball for all three perspectives.  Otherwise you’ve failed.

For example, I’ve seen user experience people run wild with feature ideas, not paying attention to the development cost that such features incur.  I’ve seen the opposite as well – web apps with terrible user experiences that are vulnerable to losing market share to better designed products.

I’ve seen project sponsors focus on business value at the expense of user value, and then are surprised when no one uses their product.  I’ve seen projects that have been managed perfectly for schedule and budget (perfect scores to the project manager) fail in the open marketplace because they didn’t bring value.

Which Brings Me to the Siloing Part…

So to really succeed, you need to synthesize all three perspectives into a unified vision.  That’s why it drives me crazy to see so many people in web development so oblivious and willfully ignorant of perspectives other than their “native” perspective.  UX people that make features up without understanding development cost.  Developers that launch features without considering a usable interface.  PMs that manage schedule and budget without comprehending the quality of what they’re developing.

Do you really want to be good at this?  Then learn about the perspectives that are different from what you deal with every day.  UX people should understand the constraints (and advantages) that technology puts on development.  Developers should appreciate the business goals and usability issues related to the products they develop, and PMs should understand the vision of the products they’re managing.

Process is Not The Answer

Process alone, especially any process that involves creation of a bunch of intermediate documents or getting people to show up for a bunch of meetings, is not going to fix this.  The people who work on web applications need to internalize the other perspectives, and make it their personal responsibility to understand this.

Once this happens, an organization can support people by offering pathways to education (courses, books, conferences etc), but the people need to personally commit.

Admittedly this makes a barrier to scaling, because not everyone is interested in other perspectives.  They got into their own discipline (development, project management, visual design, UX etc) for a reason, and that’s where they want to stay.

My view is that the willingness to see the other perspectives is what separate the truly talented from the mediocre, and the mediocre will not be working for me any time soon.

In part one we learned about Client Risk: risk that clients bring when they walk through the door.  Based on attributes such as the ability to make decisions, relative insensitivity to price and technology agnosticism, clients can either be part of the problem or part of the solution when it comes to managing risk.

In part two we learned about Structural Risk: risk that is derived from how the team is structured – whether they are familiar with each other, a common process, the tech or the client.  In some ways this type of risk is learning curve risk, because it models how many learning curves are piled onto the project.

Finally, in part three we learned about Qualitative Risk: risk that is driven from the quality of the team, the technology and the support for the team.  The better these things are, the more curve balls they can handle, and the more they can cope with risk from the other vectors.

From each of these three aspects of risk we derived an overall letter grade: from A to F.

Putting it All Together

Here’s how the letter grades combine:

Low Risk: All A’s and B’s

This is a good to great project with minimal risk.  In this range you can count on projects staying on track, and arriving where they are supposed to within budget, on schedule and at a level of quality that will satisfy everyone.

Medium Risk: One or Two C’s

This is a project that has a combination of a relatively problematic client, an immature team, or mediocre quality issues.  It is possible to succeed in this space, but it requires a close watch and quick action to mitigate the problems that inevitably will come up.  The success of the project depends on at least on of the three areas being better than the “C” level – the strength that can hold up the project.

High Risk: Three C’s or One or Two D’s

This is a project that, from its onset, has a good chance of going bad.  Either there is no strong area that pulls the project up to the medium risk level, or there is one or more areas with real problems: a truly high risk client, an immature team or poor quality from the team, the technology or the team’s support system.

Despite the best risk-mitigating activity from management, there is still a good chance that this project will go wrong.  It would be  a sound decision to walk away from such a project, but if taking it on is necessary, then it should be approached extremely defensively, as there will inevitably be serious crises as the project progresses.

Lead Balloon: One or more F’s, or 3 D’s

This is either a project with an impossible client, a disastrous team, or a catastrophic quality issue; or it is a project that is merely poor in all three areas.

Generally speaking, it is not possible to be successful with such a project.  The presence of the F will sink the project on its own, or the general malaise of the 3 D’s will accumulate into a disaster.

A project at this level needs a fundamental reset: generally either the client or the team has to go, depending on the source of the problems.  Risk mitigation at this level will be overwhelmed.

Conclusion

So there you go – my general theory of project risk.  I hope that you find it helpful, and through it gain a greater understanding of why projects succeed and fail, and when to plunge ahead, and when to run the other way.  Good luck!

In Part 1 we discussed client driven risk – the problems that clients bring to the table and how they affect the project.  In Part 2 we discussed structural risk – risk that originates with the composition of the team working on the project.

The third and list type of risk I call Qualitative Risk.  This is a kind of risk that is affected by the quality of the tools and people executing the project.  Everything counts, everything matters.  Quality affects the project.

There is a school of thought in business that would dearly like to factor quality out of the equation.  Businesses that trade in commoditized markets, competing on price, basically operate on the supposition that there is a standard level of quality and that it is not a distinguishing characteristic.  The movement towards off-shoring software development included an attempt to factor out quality.  Command-and-control programming languages like Java and .NET are attempts to engineer developer quality out of the equation – at least partially.

Quality, however, matters.  The web development framework you choose will affect the project, positively or negatively.  The skills of the developers you hire will affect the project.  It is not just subjective, some of these things are actually better than others.

I break Quality factors down into 3 main pillars: Team, Tech and Support.

Team: How strong is the team?  My feeling is there should be at least 1 really good senior developer for every 3 medium or junior developers on staff.  In addition, it is good to have at least a couple of honest-to-goodness rock stars around – the people who can be thrown against any technical challenge and still land on their feet.  The bar should be set at a level where the team can be counted on to astonish you on at least a semi-regular basis.

Tech: How good is the tech on which you’re building this thing?  Does it provide features that you need?  Does it provide a means of accelerating custom development, in case you need to go outside those features?  How often is time spent using the technology solving actual business problems, as opposed to just servicing the demanded ceremonies of the technology?  When is the technology enabling you, and when are you fighting it?

Support: The infrastructure: managerial, administrative, legal, HR etc., that surrounds the team – how much is it helping?  Is HR effective in finding new talent?  How about support from IT?  Is it straightforward to get ticket systems, continuous integration servers, new virtual servers etc. set up?  Or does every request take forever, with the development team resorting to circumventing the company infrastructure?  Does management back and support the development team, or are they selling them up the river?

Each of these pillars is deep and complicated, so grading them is a little abstract.  However if you set an aggregate grade for each pillar and take the average you’ll get a sense of the qualitative risk associated with the project.  Again, starting about the C grade and intensifying as you drop below that, you can easily get to a level of unacceptable risk.

In the next and final installment of this series – we’ll look at putting all the various risk factors, client-driven, structural and qualitative, into an overall risk profile.

I like to call this second category Structural Risk, because it has to do with how a project is structured: the parts that make it up.  Again, to take the positive angle – each point below is listed in its non-risk-adding, positive side:

• The team has worked together before. The team itself is a known quantity, with the individual talents and personalities of each team member known to the group.  This knowledge allows team members to guide the project to leverage the various strengths and avoid the weaknesses of the individuals on the team, working together to achieve the highest level of productivity.  Also hopefully people like and respect each other.
• The team knows the technology. It is a technology that the team has worked with before – they know how to work with it rather than wind up fighting it.  They are unlikely to be surprised by strange quirks of the tech stack that creep up at the most inopportune times.
• The team knows the client. The team has worked with this client before, and therefore knows the business problems that intersect their space.  This way they will be less likely to make poor assumptions about how things are supposed to work.  Functional specs are great, but they don’t take the place of actual domain knowledge on the part of the team.
• The team has a methodology for staying on track. Without getting into the comparative merits of individual development methodologies, the main point is that the team has a way to prioritize, track progress, and correct problems early on.  A team that can’t tell that it’s off-course can’t correct.
• The team can effectively communicate to management, and vice-versa. The cliche is that management understands different levels of priority for requirements, but sees all cost of implementation as equal.  Developers see different costs of implementation, but imagine all requirements to be equally important.  Neither is true, of course, and there needs to be an effective channel for technical and business stakeholders to properly communicate with each other.  A Tech Lead can be an effective method here.

Note that none of this discusses the individual experience or quality of the members of the team.  This is structural.  Process and management – all about getting people to speak with each other, and work well together.

Again 1 point for each “yes” answer for your team, just like in part one.

5 points: A. Your team knows each other, the client and the means to success like the back of their hand.  You’ve probably already made the mistakes you are going to make, so you can count on solid execution from people.

4 points: B. Still solid.  B is as good as a team can get with a new client (and at least in agency work new clients are frequent).  B is structurally still a good risk, but can occasionally throw up a surprise or two.

3 points: C. Medium risk.  At this level there is at least some degree of immaturity in the team – it may reflect new hires, or the creation of a new team where there wasn’t one before.  The team is still working out the kinks in their process.

2 points: D. This is an immature team.  There are enough unknowns going on at this level that the team can easily trip over itself, adding significant risk to a project.  Watch out.

1 and below: F. The team is not ready for this project.  The structural problems will create a significant negative impact on the project, probably leading to some level of failure.

To be concluded in part 3, where we’ll look at qualitative risk, and how to combine all the risk factors together into a single model.

Okay, no one buys that exactly, but there is a certain amount of seeming randomness in software or web development that makes developers and managers both very, very nervous when entering new endeavors.  Everyone knows from past experience that even with the best of intentions, things seem to occasionally go terribly wrong.

I’d like to suggest that things happen for a reason, however.  In the case of software development projects, there are specific patterns and phenomena that drive projects towards success or failure, and that learning to recognize those patterns can lead one to manage them much better.

In fact I would take that one step further, and say that these patterns can actually be modeled, and together form a bit of a magic 8-ball on what’s likely to happen with the project.

Clients

Many software development projects have clients involved, and for many of them the problems start right there.  Clients present an extremely powerful influence over projects, because if they are not happy, there is no business.  Clients do not always act in their own best interests however, or the best interests for the project.  Therein lies the rub.

I’ve identified a specific set of criteria that identifies good clients.  Clients with these attributes are good, those without them are bad.  Howe much risk a client brings to a project depends on how many items on this list they rate.

• Strong decision maker: Is there someone (much preferably an individual person) who can make decisions in the client organization?  Or is there a distributed set of stakeholders, all with different agendas, values and visions about what the product should be?
• Reasonably Insensitive to Price: Does the client appreciate the value of what they’re getting?  Or do they just want to slash, slash, slash prices and get the cheapest possible version of their site?  Do they argue over every last nickle and dime?
• Technology Agnostic: Tech matters.  Anyone who says differently is ignorant or lying.  The choices of hosting, frameworks, platforms, products etc all compound and add or remove risk from the project.  Good clients are ones that allow and encourage the best tools for the jobs to be used.  Bad clients come in the door with corporate technology mandates that have nothing to do with the specific interests of the project.
• On a Reasonable Deadline, but Flexible on Scope: Projects need schedules in order to happen, but the uncertainty baked into programming demands that something in the classic project management triangle flex, and the best thing to flex is scope.  When there is a clearly prioritized set of features on the table, the upcoming release may or may not have certain features, or they may be implemented at a number of different levels of complexity.  Hard features of limited business or user value should be jettisoned.
• Savvy: Good clients know their own business, the Internet and so forth.  Clients that require teaching on every last point that intersects the project slows things down, and opens the door for them to make bad decisions.  A client that is reasonably well educated on their space and how it relates to the project will be much less off than others.

Grading

For your client, award 1 point for each of the above criteria.

5 points: A. Run, don’t walk and get this client’s business.  They are extremely rare and can be the basis of an excellent partnership in which you can do great things.

4 points: B. A good, run of the mill client.  Will occasionally do something bothersome, but well within the parameters of something that can be managed for success.

3 points: C. Fair.  This is starting to get into the range where client risk can adversely affect the project.  If it is combined from risk from other factors, failure can occur.  Nonetheless it is possible to succeed with a C client.

2 points: D. Not good.  This is a high-risk client, and this kind of work should only be taken on if painstaking steps are taken to protect the team from bad influences and decisions made by the client.  A large amount of time will be spent on keeping this client under control, and preventing them from damaging the project.  It better be worth it.

1 and below: F. This client brings disaster with them.  It is almost impossible to succeed with this kind of client, and it usually isn’t worth it.  They will be a never-ending source of problems, and will compel bad decisions that will most likely derail the project.  Avoid.

Continued in part 2, when we’ll look at some of the other risk factors that bear on a project.

UPDATE: Okay, so I covered some of this before, but this is part of the model, so its sort of from the opposite tack.

A mathematician sits on a park bench next to a pretty girl.  He wants to move closer but is struck by the helplessness of the situation: he’ll move half the distance, then half of the remaining distance, then half of that, and so on and so on – but will never actually reach the girl because the remaining distance can always be halved.

Later an engineer finds themselves in the same position.  Like the mathematician, he knows its impossible to actually reach the girl, but he realizes he can get close enough for all practical purposes.

(Okay, it is, and has always been, a dumb joke.  But it’s about how engineers think, and that’s what I want to talk about.)

Engineers solve problems.  In order to solve problems, they need to identify them.  They need to get down in the detailed muck of whatever it is at hand so they can see how things work and find a solution.  This is called “getting your hands dirty”.

Most people are afraid of problems.  Problems make them feel like victims – helpless to control their fate.  They’re used to problems making life worse for them, without any available solutions.

Engineers, on the other hand, relish the thought of new problems.  After all, they’re used to having problems fall before their mental prowess – sliced into bits by [[Occam's_Razor | Occam's Razor]].  The existence of problems is enjoyable to an engineer: it gives them something to do.  To most, however, the existence of problems is upsetting.

And that brings us to salespeople.  Salespeople identify problems that upset people, and they sell solutions to those problems.  (And since this is a web agency post, by “solutions” I mean “websites”).  In theory, people will feel better because their problems have now been solved. The salesperson also feels better because they now have money.

Now what salespeople don’t want to do is dwell on the problem..  They want to talk about the solution.  No problems should escape the solution.  The solution leads to the sale.  Focus on the solution.  Always Be Closing.  Dwelling on problems creates doubt in the mind of non-engineers, and doubt screws up closing the deal.

So, ultimately, the salesperson wants to play down any problems that are not solved by signing the deal, whereas the engineer wants to dwell on them in detail.  Disconnect.

Weird things can start to happen when you bring an engineer into a sales situation; something that is occasionally necessary.  In the web agency world, the art of deal making is that the sale is made long before it’s clear what is being sold.  For n dollars, something will be built that will do something on the lines of solving these business problems.  Sort of.  Give or take.

This is totally backwards to the engineer, who, in their problem solving mindset, wants to be given a problem to solve.  A set of metrics for success.  A clearly defined goal.  But that’s not the way agencies work.  First you pay, later you find out what you get.

In order to close the deal, the salesperson needs to keep out of the details, and basically imply that the website will do everything that the client wants, but without actually promising anything specific.  The danger to the salesperson is that the engineer, being detail conscious, will screw this up.

The danger for the engineer is that the salesperson might sell something that simply can’t be delivered for the specified budget.  Or perhaps commits the engineering team to a ridiculous technical constraint that adds so much risk to the project, or is so onerous, that what started as a simple project becomes a nightmare.

When an agency works well, there’s a kind of dance between sales and engineering, where sales gets deals done without being drawn down into the muck of engineering, but doesn’t create any deals too stupid for engineering to be able to deliver.

When sales and engineering don’t sufficiently trust or respect each other the dance breaks down.  Then sales closes deals that are impossible, and engineering bogs sales negotiations down in details that simply shouldn’t see the light of day until the ink dries on the contract.

On the business side you have project managers, new business types (aka salespeople), and other bean counters.   These people basically care about money: making it and not losing it.  Making cool stuff is a fortunate side effect at best.

On the tech side you have developers and (in a way) [[User_experience|UX types]].  These people love solving problems.  Give them a problem, they want to solve it – preferably in the most awesome, beautiful and elegant way possible.  On a deep, soul searching, emotional level, they don’t give a flying crap about the money.

Funny things happen when members of these two groups speak with each other.  They describe things using the same words, but they mean fundamentally different things.

It’s very common for the business types in Group A to approach the problem solvers in Group B and ask them a question like “would it be possible to add some snazzle on the frozbot”?  At this point the problem solver gets a far-away look in their eyes and replies “yes, it’s possible”.

Hey, business types: the problem solvers are talking about something entirely differently than what you have in mind.  If you’ve just inferred from their response that you can squeeze that new feature into the project, you’re wrong.  At least potentially you’re wrong.  You actually don’t have any more information than when you started, because the problem solver’s answer actually contains no useful information to you whatsoever.

What you wanted to know was:

“Can I get this extra feature into this project,  it in a way so that I continue to make money?”

What they just really answered was:

“Yes, with nigh infinite time, resources and money, this snazzle can be retrofitted onto the frozbot, in a fabulous dimension of mind over matter where this crappy project doesn’t exist”.

Which, business person, was, of course, not your question.

You see, you thought the money part was implied.  And, to another business type, it would have been.  But as was noted above, the problem solver is not inferring that part.

So I propose you stop asking the question “Is It Possible” altogether.  It’s a useless question.  Instead, I suggest you ask “does it FIT”.

My new favorite acronym – FIT.  Feasible Inside Triangle.  The triangle being, of course, the classic project triangle of Scope, Schedule and Budget.  By including the triangle within the question, the problem solver has to take its constraints as part of the equation.

This is an adjustment at first, but they’ll get used to it.  The barre has been raised.  Business types can expect a lot more up-front pushback to “does it FIT” than “is it possible”.  A lot more “no way”s.  However this is better than the alternative, where people say “yes” and then a project disaster ensues.  FIT forces people to be realists.

This communication barrier between business and problem solver types is really dysfunctional, and has probably led to millions and millions of dollars of waste.  Let’s stop lying to ourselves about feasibility in projects, and keep our problem solving powers relevant to reality.

The idea of maintaining a single technology stack in a development shop is quite appealing.  If everyone knows the same programming language (the thinking goes), the same web framework, the same RDBMS and so forth, then life would be better.  Business really likes this kind of thinking.  It promises efficiencies of scale, reduced training costs, and easily replaceable employees.  This kind of “one true technology” approach is the foundational philosophy of corporate darlings Java and .NET.    Once you have the organization standardized on the tech, it is promised, then every part will play nicely with every other part, critical dependencies (such as employees) will be reduced, and the whole “what are we doing about technology” question just goes away.

Now, of course I support operational efficiencies, reducing training costs (well, to an extent: I view training as an investment), and so forth, but I think that the idea of “one true stack”, especially in service-oriented tech shops like web agencies, is a pipe dream.  The advantages of standardizing an entire company on a single tech stack are outweighed by the disadvantages.

Before I get into that, however, I want to introduce the idea of a “jealous” technology.  A jealous technology tries to take over as many aspects of the stack as possible; mandating a specific component at each level.  Some technologies are more “jealous” than others.  Microsoft is notoriously jealous:  the Microsoft web framework, ASP.NET, really wants to be deployed on the Microsoft web server: IIS, on the Microsoft operating system: Windows, backed by the Microsoft RDBMS: SQL Server.  Other combinations (yes, I know about Mono) simply don’t work as well.  And, on the other hand, Windows is something of a second-class deployment platform for most other web technologies (ever try to deploy Rails on Windows…with IIS?  Yuck…)

Speaking of Ruby on Rails, they’ve become a bit of a jealous technology themselves.  Rails projects now prefer a particular JavaScript framework (Prototype), version control system (Git), editor (TextMate), build system (Capistrano) and development operating system (OS X).  (As well as, obviously, programming language: Ruby). While it’s certainly not as bad as the Microsoft scenario,  I do have to ask the question as to why the web framework has any influence over what version control system I use.  Do you have to use all the technologies that I’ve listed above with Rails?  No, of course not.  But they are preferred.  Things go better with Coke Capistrano.

The point is that some technologies are better suited towards certain problems than others, and a blanket organizational standardization on a single tech stack leads to a tremendous amount of wasted energy spent on driving square pegs into round holes.  Ruby is not a great foundation for an enterprise-class messaging framework.  Java is not a good choice for a lightweight CMS.  And anything other than .NET is a bad choice for an app destined to be maintained by a bunch of MSDN types.

In fact, I’d argue that the cost of operation efficiencies lost by maintaining multiple tech stacks is exceeded by the cost of jamming technologies into inappropriate use cases.  So, as messy as it sounds, any technical organization that is project or service based (as opposed to being exclusively product based) should maintain a strategic “quiver” of different technologies, so it can deploy the best choice when faced with a business problem.  Otherwise a fragile [[Monoculture_(computer_science) | monoculture]] is created, wasting a tremendous amount of developer effort, and adding artificial risk and expense to projects.

Over time I have identified 5 factors that clients bring to the table, that directly affect the outcome of a web project.  These factors can accumulate and ultimately swing the fate of a project from success to failure or vice-versa.

Here they are:

Don’t Be Overly Price Sensitive

Guess what?  Agencies are expensive.  If you want to build a website on the cheap, you probably don’t want to deal with an agency, you want to keep the project in-house as much as possible, and outsource the rest to individual contractors.  Quality can suffer this way, because you are now the web project manager (and presumably you have something else to do), but it theoretically can be cheaper.  Trying to pinch pennies with an agency can cause compromises in the quality or scope of your project that can be hard to predict.

Be Flexible on Features

Clients who want to control every last feature can lose sight of the main goal: getting a working web site that meets their business goals launched. In my experience, the best projects are ones with strict deadlines, but with some flexibility in scope.  Over the course of production, hard decisions may need to be made about whether features should be included in the upcoming release.  Generally speaking, being flexible on features, but sticking to the established release schedule, is the right decision almost every time.

Be Decisive

Clients who are indecisive, or who have decision-by-committee issues, bring risk to web agency projects.  The best projects are ones where there is a single project owner on the client’s side, who is empowered to make decisions and grant approvals about the web site.  The ability to provide clear, timely feedback and direction to the web agency is essential.  On the other hand, a client that waffles, takes forever to make approvals, or sends mixed signals to the agency just makes everything harder.

Trust and Defer

Trust the web agency, they know the web, that’s what you’re paying them for.  If you don’t feel like you can trust them, then you shouldn’t hire them in the first place.  In order for an agency to operate efficiently, it needs a certain amount of autonomy and independence from the client.  Only then can it employ its internal best practices, and do the best job it can.  Micromanaging an agency actually removes value for the client.

Be Savvy

Understand the web.  Understand your own business.  Understand how web agencies work, if possible.  The more sophisticated you are, the better the project will run.  In the past I’ve known clients who have asked for web sites, who never actually use the Internet themselves.  How could they make informed decisions about their own web site, if they spend no time on the web?  By taking the time to educate yourself about the environment in which your project lives, you’ll be stacking the odds in your favor.

There it is – clients that get all of these items right are a pleasure to work with, and they tend to get fantastic results from the agencies they use.  At the other end of the scale, clients that come down on the wrong side of all of these points can create situations that can be difficult or impossible for agencies to rescue.  By mastering these factors as a client, you’ll be doing the most you can to ensure the success of your project.

The proper use of the Alpha and Beta terminology are to describe early pre-releases of software, for the purpose of making the software available for late-stage acceptance testing.  Alpha and Beta software is, by definition, not ready for prime time.

Of course, this very concept is all rooted in pre-Internet shrink-wrapped software.  The Gold master was a CD, (or a cassette tape etc) that was physically shipped out.  It was critical to get the app into a stable state, because once it shipped it would be expensive to patch it.

With websites, the code that runs them is updated all the time.  I can pretty much guarantee that with any major website you frequent, the code that’s running it this month is slightly different from what was running it last month.  Or yesterday, for that matter.  The entire concept of releases is somewhat nebulous on the web.

But the business world thinks that software terminology is cool.  So we’ve labeled every web 2.0 website “Beta”.  It’s pretty widely understood now that “Beta” means “don’t blame us too hard if there’s bugs”.

In the agency world, there’s an even more shadowy use of these greek letters.  It has become a kind of psychological trick used to get clients to focus on only essential features.  It goes something like this:

Client:  I want a website with 8 million features of dubious value.  And a pony.
Vendor: Okay, okay.  We’ll get you that pony.  But let’s get the real core stuff out the door first.
Client: I want a pony!
Vendor: Okay, well how about we release Alpha this year with the core features, then Beta the year after that.  Then, we can focus on getting that pony for you in the 1.0 release, in two years.
Client: Well, okay.  As long as I get a pony for 1.0, then.

In a sane universe, these would simply be considered different releases: 1.0, 2.0 and 3.0.  But that doesn’t score the proper political points.  All that stuff that the client read about in Wired magazine has to make it into 1.0 in their minds, so the agency responds by re-defining what 1.0 means.  And that means abusing the Alpha and Beta terms.