Skip to content

It’s a Remote Control

In about 2 weeks Apple may or may not announce a product that may or may not be called the iSlate, or iPad, or iTablet or whatever.  Speculation is currently absolutely rampant across the digirati.  Some say it it will be an e-reader, some say a big iPod, some say a netbook Mac.

I’m going to go out on a limb: it’s the ultimate remote control.

This is entering the age of networked hardware.  The “internet fridge” concept that nose-dived 10 years ago is back with a vengeance: hardware will be on the net, addresses web services.  Cars, appliances, strange boxes that you connect to your TV and home – all of these need user interfaces.

However, UI’s are both expensive to build, and frankly hard to pull off well.  That’s why we’ve seen generation after generation of terrible UI’s from hardware manufacturers – each being forced to reinvent the wheel over and over.

But now – why bother?  Apple creates tools to build pretty good application UI’s without an overwhelming amount of work – and a streamlined mechanism (the iTunes app store) to distribute them.  So instead of sinking a lot of cost into developing your own complete user interface for your hardware – why not just hook up to an app on a device that the user already owns?

There are already examples of this in the wild: the ZipCar iTunes app will actually unlock your car.  If you invest in a Sonos sound system, you can run it from an iPhone app.  And apparently the Ford Sync system is slated to run apps that you’ll be able to buy from the iTunes store.

So what might be possible if you had a 10-inch device that could act as a remote?  Run a gigantic entertainment system?  Dock in any piece of hardware and become a touch screen control for it?  How about I use an “iSlate” to start my car?  A $700 device isn’t that much against a $20,000 car.  Or – how about running your home?  AC, Heating, security etc could all be run from the iWhatever.

Using the standard user interface SDK and guidelines, people build controls for hardware based on behavior that is already well understood.  The learning curve is reduced, and companies don’t have to sink a lot of money into UI development for their devices.  It’s a slam dunk.

Posted in Uncategorized.

No comments

By loren – January 17, 2010

I.T. Organizations Considered Harmful

Okay, this post is going to be a big shot across the bow, and for that reason I’ve waited a bit to post it – in order to try to get my thoughts together.

Having spend the last 4 years or so working in web agencies, I’ve seen the inner workings of the IT department in many, many companies – from mom and pop operations to Fortune 500 outfits. More often than not, the IT department is really, really broken.

First, let’s have a look at what broken means:

Symptoms

Lack of Prioritization

Faced with conflicting demands from different business units, the IT group is unable to plan where to spend its energy, and so lives constantly in a reactive state, servicing whatever the squeakiest wheel happens to be at any given moment. Essentially it’s locked into a state of putting out fires, and is unable to put energy into actually making things better.

Often this can be a result of lack of “informed power” regarding the IT department: senior management doesn’t really have the understanding to view IT as an allocatable asset, and no one in IT has the power to push back on the immediacy of the next business stakeholder’s fire – regardless of whether it’s important to the business or not.

Lack of Bandwidth

Related to the prioritization issue, but slightly different, is the fact that most IT organizations simply don’t have enough people to do the volume of IT work demanded by the organization. At the same time, however, there is resistance to hiring in IT, because IT is viewed as a pure cost center in most organizations. In other words, it is not viewed as a vehicle through which the organization can make money, but rather just a place where spending occurs. In an environment of cutbacks, it will be trimmed.

Communication Problems

Often business stakeholders and IT just can’t understand what the hell each other is saying. Business users generally have a sense that certain features are vastly more important than others, but don’t always communicate this prioritization if they’re not asked. Additionally they may jump immediately to a specific feature implementation (that may be taken as a requirement by IT) that isn’t really what is best for them. Business stakeholders are not going to have any sense of feasibility, however: they don’t know how hard it’s going to be to do things.

IT comes from the opposite end. They understand feasibility, but not business importance. Unfortunately IT has the habit of taking all “requirements” from business as of equal importance, and just plugging away, looking at things purely from a feasibility perspective. When combined with the business stakeholder’s habit of proscribing features instead of just stating needs, it can lead to a lot of wasted effort.

Fortress Mentality

When things go wrong with technology, who get’s blamed? IT. When things go right, who get’s credit? No one.

In a sane business decision, one weighs the upside against the risk. There are many cases where it’s worth it to take a risk in order to achieve a big payoff. But IT is essentially balancing risk against an upside of zero. Naturally, that means they will seek risk avoidance in every case. This minimizes the chances of things going wrong, but it also minimizes benefits that might be had from technology.

Consequences

These symptoms turn an organization’s interactions with their own IT group into a big, dysfunctional dance. Business stakeholders feel that IT is unresponsive, slow to complete projects, incomprehensible and too restrictive. They start to come to the blanket judgment that IT is not going to be a solution for their problems.

IT for their part, feels under-appreciated, constantly putting out fires, under-staffed and forever dealing with clueless users. They have ideas for how to make things better, but never have time to implement them. On the projects that they do get to work on, they’re shocked to find out that features they’ve worked so hard to implement are being unused by business stakeholders.

This dysfunction has even led to a culture of circumventing IT. Business stakeholders (as much as they might like to) realize that they simply cannot live without having certain technology services performed, but feel that IT will be unable to help them. At this point they may look for outside help – either from product vendors that claim to “do it all”, to agencies that usually make the same claim.

The product vendors or agencies may be just fine, but that doesn’t change the fact that the organization has chosen to outsource a part of its business, not on the basis that it isn’t core to their enterprise, but rather on the basis that they are incompetent to execute. Since IT work is often the automation of a core business process, outsourcing it can lead to a weaker overall organization.

So there’s a picture that’s probably familiar to many. How do we fix it though?

How to Fix IT

Fix the Accounting

If technology has benefit to an organization, then that benefit needs to be reflected in the way the organization accounts for itself. From a financial perspective, a business will look at the profitability of its various components (at various levels of formality, depending on the size of the business) and make decisions about where to invest.

Businesses need to stop looking at IT as pure cost centers. That means that the credit for adding value to business units needs to find it’s way back to IT somehow, and be measured against IT costs. Here’s two possible ways to do that:

Charge the Business Users

If business stakeholders use IT services, they have to pay for them. That way the “cost of IT” lands squarely on the business stakeholders that use IT services. Of course, the side effect of this is that the quality of what the business users are paying for will immediately fall under scrutiny, but that’s okay. The point is to make the organization stronger.

Credit IT with Results

Let’s say IT builds a system for a business group, and as a result there is a reduction of cost for that business group (or even better, a measurable increase in revenue). Some of that savings/earnings increase should again be credited back to the IT department, and shown as income (or something equivalent). Again the political side of this action will be determining how much credit to kick back to IT. Too much would additionally have the negative side effect of making the business groups less interested in such activities, as they aren’t being credited with the results.

Hire Technology Leadership

Particularly aimed at the communication / prioritization issues, the solution is to hire a senior person with a technology background who:

Can Translate: Someone who can speak the feasibility-heavy language of developers, and the priority-heavy language of business stakeholders. Someone who knows when to ask context-breaking questions, such as identifying the real business issues instead of just accepting prematurely prescribed solutions dictated by business stakeholders.

Can Design Solutions: Someone who can take the real business requirements and come up with a technology-based solution, then take that solution and articulate it as technical requirements for the IT Staff. This is an individual who understands both technology and business.

Has Authority: This person needs to be able to push back. It is inevitable that forces within the organization will attempt to mis-use IT, either pre-selecting the wrong solution, or by short-circuiting the priorities of the IT group. The Tech Lead has to be able to say no to those forces, and find a real solution that balances the real needs of the business stakeholders within the larger context of the organization.

Decompose IT

The most radical step is to send IT staff out into the wilds of business stakeholders. Instead of a common pool of IT resources, an organization could choose to send, for example, a technical PM, a couple of developers and a sysadmin out to exclusively work on the problems of a particular business group.

This is an approach that probably makes the most sense when the needs of a business group grow beyond a certain point. At that point using centralized IT resources becomes less effective than maintaining their own technical staff. The obvious concern is that efficiencies of scale are lost when technical resources are distributed amongst business groups, but this is a good choice when the effectiveness of those resources within the individual business groups makes up for any loss from decentralization.

The upside to decentralization is that the accounting problems just go away. The efforts and results of these distributed staff are just measured within the individual business group, who will either be able to justify the expense or not, on the same kind of merits that they use for everything else.

It is important in these cases that technology leadership/management is included in the distribution, or the business units can find themselves saddled with a lot of the communication issues mentioned above. Because of this, this is a significant and potentially expensive step for a business group.

Conclusion

IT in most organizations is broken – it’s not providing the kind of support and advantages to business users that it could, and is the source of frustration and feelings of helplessness for many employees, both business and tech. By re-structuring the way IT fits into organizations, it can deliver on it promise at last.

Posted in business, tech strategy.

Tagged with .

No comments

By loren – August 23, 2009

Modeling Risk (Part 4) – Putting It All Together

In this, the final installment of the Modeling Risk series, we going to put together everything we covered in the previous installments into a unified risk model.

risk

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!

Posted in business, programming, web agency.

Tagged with .

No comments

By loren – August 19, 2009

Modeling Risk (Part 3): Quality

The plot so far:  there are specific things that cause project’s to fail, beyond the abilities of seemingly competent people to control.  These forces aren’t random, they are specific patterns and antipatterns that create accumulating risk that bears down on projects like debt.

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.

Posted in programming, web agency.

No comments

By loren – August 6, 2009

Modeling Risk (Part 2)

In part one we had a look at risk that comes to the project from the client, before it even starts.  This time we’ll look at risk that comes from the composition of the project and the project team.

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.

Posted in business, programming, web agency.

Tagged with , .

No comments

By loren – August 1, 2009

Modeling Risk

Why do some software / web projects run off the rails so badly?  Are we just incompetent?  Is it that the very practice of programming is so incredibly difficult that it defies any attempt to manage it?  Perhaps software development is just an inherently terrible idea, and we should leave it up to Microsoft to handle, and focus on other things, such as selecting the best clip-art for our PowerPoint slides.

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.

Posted in business, programming, web agency.

Tagged with , .

No comments

By loren – July 25, 2009

Obligatory Whining About Not Posting

Yes, this is my blog. No, nothing has happened here for some time.

About 11 months ago I became the Director of Technology for HUGE. This took a lot of my brainpower over, and the most immediate casualty was Antipatter. Mea culpa.

I’ve made fun of well meaning friends who have, in the past, spent a lot of time developing their own blog software, but haven’t really posted much. Of course they are now kicking my butt.
Then I became tired of the brown theme, and have spent too much time screwing around with the look and feel. That needs to change, but not at the expense of posting.

Finally, Twitter enables laziness in blogging on my part. Instead of developing an idea enough to blog it, it’s really easy for me to knock out 3 or 4 tweets that capture the barebones essence of my point. This is just lame.

So while I can’t really promise a particular frequency of posting here, I will do my best to put something up once in awhile. I’ve certainly had thoughts that could have gone up here in the last year, it’s just a matter of capturing them and getting them posted.

Posted in meta.

No comments

By loren – July 18, 2009

Golf Course Technology

Why does enterprise technology suck?  Oh yes, of course, it has lots of features, far more than smaller, more compact versions of the same kind of technology, and additionally it often has hooks that allow IT departments to manage it in large deployments (I’m typically thinking about features such as Single Sign On).  And typically, but not always, it’s built to scale: many users, much data, many processors etc.

However it also typically sucks.  Sucks balls.

You’ll Eat It, And You’ll Like It

The basic mechanic underlying enterprise software sales is that the person making the purchasing decision doesn’t have to actually use the stuff.  Image, if you will, a hypothetical golf course where your CEO and the vendor’s CEO are playing a game.  A deal is being made.  Backs are being mutually scratched.  Soon you will be using the vendors stuff, regardless if whether it’s the best fit for the problem.

In this scenario the software is just a transaction.  Money moves hands, brownie points are earned, and a solution is tossed at a not-particularly-exciting internal logistics problem.  Whether its the best fit for the problem, and certainly whether its a good tool, are simply not considerations.  Interestingly, a lot of this is driven by the people at the top – if, for example, they don’t have to actually directly deal with a payroll system, they’re unlikely to care much about its user interface.

Faces of Lame

Speaking of user interface, that’s usually the first victim to be sacrificed with enterprise software.  User interfaces on enterprise are software are typically, oh how shall I put this, fugly as all hell.  Three things drive this: the first is the hypothetical golf course described above, the second is that every time a new feature is added to software the load on the ability of the user interface to represent it increases.  More features mean it’s increasingly difficult to represent well on a UI. Finally, there is a strange inertial “lowering of the barre”, in which the propagation of lame enterprise user interfaces has essentially made it okay for others to not even try.

Just One More Wafer-Thin Mint…

Another problem with enterprise software is feature bloat.  In a race to stay ahead of the competition, and to be able to compete on checklist-comparisons run by people who are unable to strategically assess software, enterprise software often is trying to do way too much.  What gets less attention is the software’s quality of implementation.  In other words, enterprise software has a million features, but they aren’t done very well.

Ironically this can also be a misguided product strategy, because (as Christensen tells us) features are only competitive advantages up until the point where the basic business problem has been solved.  That’s when software starts to commoditize, and is vulnerable to having its customer base eaten out from the low-end up.  The typical response to this is for enterprise software vendors to attempt vendor lock-in, making it inconvenient as possible to migrate away from their platform.  Hm. Do you think their interests may not be exactly aligned with yours?

We Don’t Like Your Kind Around Here

Finally, enterprise software (probably in pursuit of the vendor lock-in strategy) tends to dramatically over-scope itself, attempting to become its own ecosystem of functionality.  This might also be a kind of a not-invented-here syndrome at work.  Whatever the cause, the result is that functionality that might appropriately live elsewhere is rolled into the enterprise product, in kind of an awkward or substandard manner.  Everyone has to live with it regardless, because they’re locked into the ecosystem.  Just think about how many additional services Oracle has built into their database products, or Microsoft has tied into their operating systems.

Less is More

While it is true that giant product deployments are sometimes the right way to go, I think that as organizations we often miss the opportunity to stitch together solutions that meets our specific needs out of best-of-breed components.  Think of the UNIX principle of Small Pieces Loosely Joined.  If we can try to use software that solves smaller, more discrete problems in ways that are optimized for their problem space, then the overall technical ecosystem of our organizations will get stronger.  Instead of technology for the golf course, we’d have technology that actually helps us.  Technically savvy organizations like Google understands this – perhaps we should too.

Posted in business.

Tagged with , .

No comments

By loren – October 19, 2008

Problems, Salesmen and Engineers

Remember this old joke?

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.  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.

Posted in business, programming, web agency.

Tagged with , , .

No comments

By loren – September 22, 2008

Does it FIT?

There has always been a fundamental impedance mismatch between business and technical folk.  They seem to be living in two different worlds, each with different rules of engagement.  In fact, this is because they have different values – different things that they care about.

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) 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.

Posted in business, web agency.

Tagged with , , , , .

No comments

By loren – September 11, 2008