Remove the hiding places

Bad employees continue to be bad because they are, somehow, able to convince themselves and/or others that they aren’t bad.  They hide in all the little places that we create when we aren’t careful, scurrying to their favorite spots when things aren’t going their way.  The bad news is that we, as managers and peers, create these hideouts when we aren’t clear and when we accept anything less than clarity. The good news is that you can start fixing things immediately by being clear and demanding clarity.  Here’s what I mean:

1. Define success in unambiguous terms.  It’s unfair to fault someone for not being good if it’s not clear what “being good” means.
2. Prefer to be clear over being right.  Ditch terms like “leverage”, “strategic”, “high-level” and other words that can be defined retroactively to support any outcome.  Instead, state things in terms that can be proven right or wrong, even if that means that you’ll be proven wrong sometimes.
3. Be objective.  Measure according to the standards you’ve laid out.

One Last Chance In Private

Once you have clearly defined success and expectations, counsel your troubled employee in private.  This is a critical step, because this is where you can find out if the problem is actually yours and not theirs.  If you’ve done everything above then it should be obvious to both of you that your employee is falling short.  What you’re looking for is a sign that they understood what was expected and they simply didn’t deliver.  This private counsel is also where you can separate bad employees from immature ones.  The immature ones didn’t believe that it was important, the bad ones didn’t care that it was important.  If you find yourself counseling an immature employee, then you have a great opportunity to turn someone’s life around.  Spend a little extra time with them over the coming weeks and break things down to the smallest feasible chunks so you can provide plenty of feedback.  If they turnaround and become good then you’ve become not just a good manager, but a great one.  If they don’t turnaround, then chances are they acted immaturely when really they’re not going to get any better.

One Last Chance In Public

If private counsel didn’t work, then it’s time to go public.  Make it clear in a meeting, with other team members present, that the work (not the worker)  is unacceptable.  Once again, if you’ve defined things clearly then this should be obvious to everyone in the room.  It won’t be comfortable, but it’s important for a couple of reasons:

1. It gives peer pressure/support a chance to work.  If the team rallies around the weakest link and helps him succeed, then you have another shot at turnaround.  If the team shuns him, then it’s not going to be a fun place for him to work.
2. It sends a message to the team that you mean what you say.
3. It can begin the self selection process where they figure out that they’re in the wrong place and relocate themselves elsewhere.  It is almost always easier to have someone voluntarily leave than to have to terminate them.

3 Strikes, You’re Out

After the previous last chances, failure to improve should result in termination.  When you terminate someone, they should never be surprised.  They can be pissed, they can even be shocked because they never thought you’d actually do it, but they should have seen it coming.  Everyone should see it coming.  Most should be relieved or appreciative.

To Be Clear

After mentioning clarity so many times, it seems appropriate to make a few things explicit:

• Making things “terrible” is all about exposing bad work and making someone uncomfortable with their actions and choices.
• This is not an excuse to be mean.
• You need to be fair and objective.
• There has to be an opportunity for turnaround.
• There will be work and discomfort on your part.

Stick to your guns and prune respectfully and you’re on your way to being a good manager.  Go the extra mile and actually turn someone around and you’ll be great.  Either way, you and your team will be better off for it.

Give As Much As You Can, Then Stop

The year started with me wrapping up a contract that I had been on for more than a year and jumping back into the startup world.  I had been working on the startup during off-hours for a couple of months and had picked up some great new skills (MongoDB, IronPython, ASP.NET MVC 3, etc.)  I had negotiated my ideal combination of great salary and good equity stake and was ready to work on the company full-time.  I had no problem working for free for several months and paying some travel expenses because I really wanted to make the deal happen.  Then, it all unravelled in the course of a few days.  The partner on the business side decided that the salary I was asking was too high.  This was months after I thought we had agreed and after this partner had told our only investor that he wasn’t needed.  In the past, I probably would have compromised to make it work since I had already invested a bunch of time and effort, but I’ve matured since then.  The combination of recognizing sunk costs and having an unwavering requirement that I trust my partners led me to withdraw.  It was hard (and somewhat scary) to abandon the path that I had committed myself to for many months, but I had given all that I was willing to and once I was asked for more it was time for me to stop.  Since I had set a “if I don’t have signed paperwork by this date then I’m out” deadline, it was clear that it was time for me to leave even though it wasn’t easy.  Know what you’re willing to give, but be honest enough about it that if you’re asked for more then you stop.

It’s Hypocritical To Not Get An Outside Perspective

After leaving the startup path, I needed to figure out what was next.  Quickly.  The nervousness of not having work lined up really drove me.  Crazy.  The problem with being both driven and crazy at the same time is that you thrash.  You end up expending incredible amounts of effort for near-zero progress . . . or worse.  I was fortunate in that one of my business partners is an incredible coach and he made it clear that we needed to talk.  I don’t remember anything we discussed during the hour except him saying, “With options comes power.”  My problem was less about not knowing what to do and more about *needing* to do something. I took his overall advice of “get a few clients who will pay so you’re not dependent on any of them” and started working on my client portfolio.  After I got things back on track I realized how hypocritical it was for me to not seek an outside perspective from the beginning: That’s a big part of what I sell!

Find Enough Clients Who Can Pay

For the rest of my career, I am likely to have at least 2 clients.  An ideal number for now is 3 or 4, but it takes at least 2 in order to have options, and therefore power.  One of my clients is a startup and startups sometimes run out of money.  There’s a big difference between a client who is unwilling to pay and a client who is unable to pay.  If they’re unwilling to pay, the relationship has probably been destroyed and things quickly turn into strictly business decisions.  If a client is unable to pay, however, things are a little different.  It is in the nature of startups to reach beyond their grasp and sometimes they fall.  I happen to really like this particular client so I checked in with them once a month, but never in a mean or threatening manner.  Because I had other clients who *could* (and did) pay, I had the option of waiting.  It took a good 3 or 4 months, but they raised another round of funding, sent me a check, and we’re back to working together.  If I had been demanding or unpleasant during their inability to pay, we probably wouldn’t be working together now AND it wouldn’t have changed the fact that they couldn’t pay.  If you have enough clients who can pay, you have the option of working with some who may not . . . and they’re often the most enjoyable.

The Happiest People I Know Are Where They Put Themselves

I read a lot of blogs and talk to a lot of people about their work and their lives.  One thing that really crystallized this year is that people who are in a place intentionally are much happier than those who have “ended up” someplace.  And it’s not just the rich ones who started something that became big, it’s also the folks who decided what they wanted to do with their lives and set themselves up around that.  This is sort of an extension or evolution of, “Do what you love and the money will follow” because I think that that phrase needs a bit of updating.  I’ve seen plenty of people who love technology or software development, but are f’ing miserable because they’re in a situation not entirely of their choosing.  Chances are you know someone like this.  He liked computers and software and learned to code.  He found a job somewhere because he needed a job and things were somewhere between fine and great in the beginning.  Over time, he got worn down by the company environment until he ended up with a position he would have never consciously chosen.  But he’s stuck.  He’s afraid to go somewhere else and now he’s just kind of “ended up” doing what he’s doing.  Contrast that with someone who has created her own position to do work she enjoys, even if it doesn’t pay a lot (as long as it’s “enough”).  She’s invested in making things work.  She’s set up her work to integrate with her life.  And she has options.  If things don’t work the way she thought, she can always redesign and renegotiate the position.  She’s there by choice and since she chooses to do what’s she’s doing she’s better at it and happier overall.  When I find myself in a job because I need it, it’s not very long until it starts to wear on me.  When I’m working on a project that I helped create, however, I’m committed to it and energized by it.  I’m not suggesting that choosing your work is the answer to all your problems or the one true path to happiness, but I have observed (and lived) that people who consciously choose their work are happier than those who don’t.

Here's to a Big Swinging 2012!

In my early 20s, I started trading stock options online.

I was horrible at it. 

I was buying options, which meant I was paying someone for the ability to make a choice. 

I was in my early 20s, which meant that I made really bad choices. 

So there I was, paying someone to let me make bad choices.  I stopped in my mid 20s after I grew tired of losing money.  The concept of optionality stuck with me, however, and I’ve incorporated it into my approach to both software and clients. 

On the software side, this often means decoupling.  I don’t favor decoupling because it’s cool, I favor it because I’m wrong a lot and want to be able to fix my mistakes as quickly and easily as possible. Decoupling gives you options because it reduces the impact of changes, meaning that you can make more changes. Particularly in business software (and espectially in large enterprise systems), you can bet that change is coming.  Requirements change.  Systems that need to be integrated change.  Business processes change.  If your system can keep up with this change, it's a lot more valuable than one that can't.

On the client side, I sell a wide array of options and clients like it even if they don’t realize that that's what it is.  Instead of saying, “Here’s the deal: You pay me X and I’ll deliver Y” I almost always offer choices.  The actual choices aren't important here, the important thing is that no matter what they choose the work they need will get done.  Sometimes that means paying for my own hardware, software, hosting, etc.  Other times it means travelling to be on-site with them or their clients.  The point is, that by offering them the option(s) to do things their way, I get to charge a premium over someone who simply sells billable hours sitting in front of a screen.

If you can provide optionality that's valuable, you can sell it and collect the premium.

As a bookend to the previous mention of options trading, I returned to it recently for a bit (now in my mid-to-late 30s) and did pretty well.  The difference?  Instead of buying options, I sold them through credit spreads since I now realize that my value is in providing optionality rather than using it.

As I mentioned in the previous post, there is a lot of information surrounding this event that is valuable to any entrepreneur, executive, marketing person, or product manager.  Here are some of the lessons that I've learned from the experience:

Free Is Unlike Any Other Price

I had read that "free" is a unique price in Predictably Irrational by Dan Ariely, but there's a big difference between reading about it in a book and watching people freak out over it.  Almost all of the negative posts that I read centered around "Red-Gate said it would stay free and now it's not".  I'm guessing that there wouldn't be as much noise if the situation had been "Red-Gate said that it would stay affordable and now it's a little less so" . . . it just doesn't have the same punch, does it?  To be clear, I understand that "free" does have some unique properties: zero risk, zero acquisition friction, etc. and I'm not suggesting that people shouldn't feel they way they feel.  The lesson learned here is that "free" needs to be treated differently and that it's risky to price anything as free that can't stay that way.

All Information Gaps Will Be Filled

If you've read most of what's been written about this event, you'll notice 2 things about the information:

1. It's incomplete.
2. People will fill in the gaps with their own beliefs.

I read everything from "since Lutz got paid" and "Lutz may not have done the deal if it wasn't going to remain free" to "Reflector should go back to being open source" and  "Red-Gate installed a timebomb in it".  To the best of my knowledge, the details of the deal were never made public.  That means that unless you're Red-Gate or Lutz, you don't know the details.  As for the open sourceness and timebomb: Plenty of people have pointed out that it was never open source and the timebomb had been there for years before Red-Gate acquired it.  The lesson learned here is that any information gap will be filled by someone, at some point and that you might want to consider a defensive move of laying out relevant facts when it's time to announce an unpopular decision.

Non-Physical Products Are Different

People have a different view of non-physical products compared to physical products.  If you buy milk from the store, you don't expect it to last forever.  You know that it's an exhaustible resource that disappears as you use it.  As a physical object, it can't be 2 places at the same time.  Non-physical products have non of these limitations.  Because of this, limitations built into a non-physical product are often seen as taking something away from the end user.  DRM for music, games, and movies is a good example since it so clearly takes away capabilities from the non-physical product.  People hate DRM for a variety of reasons, but one of the most common is that it makes the non-physical product behave in unexpected ways.  All of a sudden you can't listen, play, or watch – not because your network connection went down but because someone made the media require a continuous connection.  That was a limitation that was consciously built into the product.  The timebomb in Reflector is similar.  Except for trial software, most people don't expect software to expire.  When the expiration comes, it's not only unexpected but it's clear that it was put there consciously which can lead to feelings of "you did this to me".  The lesson learned here is that if you're going to do something unexpected, make sure people are aware of it and consent to it in order to avoid an emotional response down the road.  As a point of clarity, "aware" means that they actually know what's going on which means it can't be buried in a EULA.

Developers Are Even Differenter

I lumped music, games, and movies together above when talking about non-physical products because they all have a similarity that separates them from software: most consumers can't create their equivalent.  Once you get into the realm of software, then things get a little stickier . . . all of a sudden you're talking about things that could be created by the end user, although it's often impractical for them to do so.  If you narrow things down to "developer utilities" then you're on really thin ice.  You are actually targeting a market segment that is often qualified to create the thing you're selling them.  Most of the time they'll be very rational about purchasing tools: "This will make me better.  It would take longer to create this myself then the price divided by my salary/rate.  I should buy this."  If something happens to suppress the rationality (like messing with "free"), then they can quickly go into "I don't care what it takes, I'll build it myself!" mode.  The lesson I learned is that when targeting developers as a market, it's important to avoid doing anything that might flip the rationality switch.

Conclusion

To cause the reaction we saw over the last two weeks, it's safe to say that Red-Gate made a mistake.  What's not clear is exactly where the mistake was made and what should have been done differently.  It's not clear because we don't have all of the information.  Don't let this opportunity go to waste, though.  There are some folks who paid steep tuition for the lessons that you can learn from this experience.

• Lutz Roeder created .NET Reflector many years ago (full history: http://en.wikipedia.org/wiki/.NET_Reflector)
• I venture to guess that the majority of professional .NET developers use the tool.
• Red-Gate bought Reflector in 2008 (I remember because I saw Neil Davidson at the Business of Software Conference in Boston and asked him about it).
• Reflector has been free, or had a free version available for its life thusfar.
• Red-Gate announced yesterday that they'd start charging for Reflector in March with no free version available (as far as I can tell).  The price that replaces "free": $35.
• Lots of people are going apeshit about a tool that used to be free no longer being free.

That brings us up to speed.  For some fascinating reading, check out the Red-Gate Reflector Forum.  I'm being serious here.  It isn't often that you get to see so many diverse thoughts, opinions, and expressions of outrage in one place.  ANY marketing person, product manager, executive, or entrepreneur would be wise to read the forum posts and comments for a mixture of warnings, lessons, and insight into the community/customer mind.

For my part, I don't have a strong opinion about whether Red-Gate is right or wrong on this matter and that's actually not what this post is about.  This post (like many other posts) is about behavior and action.  While I can't make Reflector free for everyone, I figure I can make it free for 10 people.  I've made enough money doing development work and consulting while using Reflector that $350 seems like a reasonable price for me to pay.  At the same time, I know that there are lots of folks out there doing good work that can't pay $35.

Post a comment about why you want a copy of Reflector by Sunday, Februrary 6th.  I'll pick 10 and buy each a $35 license of Reflector 7 upon its release.

If Red-Gate (or anyone else) should decide to match the offer, then the freebies go up from there.

UPDATE: Just got off the phone with Red-Gate and they've offered to match with 50 licenses (I'm still paying for the first 10 so I now have a total of 60 to give away).  As such, I'm extending the deadline through Friday, February 11th.

FINAL UPDATE: I was pleasantly surprised when Red Gate initially offered the additional 50 licenses, but I was blown away when I talked to them again and they offered another 50 for a total of 100.  Not only that, but they said that rather than wait for V7 to be released that they are going to be giving Reflector Pro licenses (the $95 one), which will convert to the Reflector VS license when version 7 is released!   I'll be emailing the folks who get a license on Saturday 2/12 and Sunday 2/13.  Licenses should arrive on Monday 2/14 or Tuesday 2/15. Thanks to everyone who commented!  BTW, if you missed the cutoff I see that Dan Maharry is giving away Reflector 7 licenses on his blog.

Step 1: Make It Terrible to be Bad

There are plenty of good people who are bad employees, especially in the technical world.  Since I've worked mostly in software, I'll focus there for a moment but the same principle is applicable to any industry.  My definition of a good developer is one who develops good software.  It's no surprise then that I think a bad developer is someone who doesn't develop good software.  As a manager, it's your job to make the environment unpleasant for bad employees.  Yes, you get extra points for offering up solutions to their crapitude like training and whatnot but even if you don't you can still be good manager simply by making bad employees not want to be there.  Why am I harping on this so much?  Because bad employees are a cancer to a team and they kill the team from the inside.  First we have displacement – a bad employee is sitting in the seat that could be occupied by a good one.  Next we have infection – bad employees have a very strong potential to turn others bad either by active instruction ("Here, junior dev, let me show you the wrong way") or through passive observance ("Why should I be any better if that guy sucks and he's still here?").  And finally we have repulsion – good employees don't enjoy working with bad ones so they leave.

Step 2: Make it Easy to be Good

The step is all about clearing the path for your direct reports.  Most technical people really enjoy what they do, it's all the other stupid stuff that turns what they enjoy into "work".  This is one of the reasons so many good and great developers work for start-ups, small software companies, or the few "big name" companies that you read about all the time like Google.  It's about the purity of the work as much as it is about the work itself.  This is where most companies inflict Death By 1000 Cuts – poorly managed web filtering that blocks technical blogs? Cut.  Stupid HR rules that require filling out a paper form once a month? Cut.  17" screen instead of a 24"? Cut.  Slow network, unstable email server, not enough hard drive space? Cut, cut, cut.  Sure, any given one of these isn't enough for someone to leave but put enough of them together and you've got one seriously unpleasant and ineffective environment to work in.

The steps are listed in order of importance.  Sure, you can start knocking off some of the low hanging fruit to make it easy to be good while you're putting the heat on the bad folks but you can't ignore step 1 and make it up by doing lots of step 2.  When a patient is diagnosed with cancer, the immediate focus is on eradicating the cancer not on adding lean muscle or lowering cholesterol.  Yes, the latter two can contribute to improved overall health by they simply don't matter if you don't take care of the most pressing need first.

Even though we're seeing some serious overuse, my problem isn't with the terms it's that the root words are incorrectly swapped around so much that folks have a hard time thinking about them correctly.  Sometimes everything is lumped into SaaS since it was first.  Other times Platform and Infrastructure are used synonymously.  My goal here isn't to introduce you to SaaS, PaaS, and IaaS . . . chances are you have an idea of what these are if you read this blog.  Instead, my goal is to show you a way to think about them to know what fits where including a 2-part value proposition of each.  This is especially important if you're building software that falls into one of these 3 groups.

Infrastructure-as-a-Service

Unless you work for Amazon, Rackspace, GoGrid, or one of the other big providers chances are good that you're not building IaaS.  Infrastructure is just that: the foundation where you run your system.  This service is all about providing you infrastructure components like servers and networking goodies such as load balancers, firewalls, and VPNs.  The "service" part of it is the management software that lets you click (or programmatically call) to provision new resources.  Click: new server.  Click: new network segment.  You get the idea.  The important takeaway here is that you are renting infrastructure that lets you do what you want, but it's pretty much up to you to make it do something valuable.  The 2-part value proposition of IaaS is that you can rent infrastructure instead of buying it and that someone who is better than you will be running it, provided you go with a quality provider.

Software-as-a-Service

At the other end of the spectrum, we have Software-as-a-Service.  SaaS should do something of value immediately after you sign up for it.  Sure, there may be some customization involved but the bulk of a valuable problem should be solved by the software that you're renting.  If you work for a software startup, then there's a good chance that you're working on a SaaS product or that there will be a SaaS version of your product offered in the near future (either by your company or a new competitor).  The SaaS 2-part value proposition is that you only have to pay for software you use and you have a solution to the problem that's better than what you can build in the time you have.  That last part is especially important since if you can't find something worthwhile to rent, then you've just stumbled upon a great market opportunity (or you're awful at using Google, but I'll give you the benefit of the doubt).

Platform-as-a-Service

This is actually the term that's been stuck in my head and led to this post.  PaaS should let you build something of value after signing up.  It's a step away from infrastructure in that you don't have to worry about the underlying servers and networking, but it's also a step from being SaaS because it doesn't do anything of general value until you get to work.  I think that a lot of the confusion around the term can be credited to the success of Salesforce.com.  They started as a SaaS offering and then created the first really successful PaaS offering (while continuing to offer plenty of SaaS goodness).  Their hosted Customer Relationship Management system is often cited as the first successful SaaS product.  Later they created Force.com which lets developers build new applications on top of their infrastructure.  Another factor that contributes to confusion about what constitutes PaaS is the use of the word "platform", one of the most nebulous terms in the tech industry.  I think that Architecture-as-a-Service may be a more accurate (though not necessarily better) description because what you're paying for is someone else's solutions to common development tasks. Instead of worrying about collecting data, storing it, retrieving it, searching for it, etc., you use the provided platform – its architecture.  The 2-part value proposition is that you can use the platform to build software without having to solve all of the problems common to software development.

To give a little perspective, I'm currently working on a PaaS system that will be used to create several SaaS products.  I'm using IaaS (Amazon EC2) for testing and production deployment.  So I rent from Amazon and others rent from me.  The spread between what I pay and what I charge is dependent upon my solutions to both development problems (the PaaS layer) and business problems (the SaaS apps).

Have an opinion

If I could give only one piece of advice to a software architect it would be to have an opinion. Wishy-washy architects who speak vaguely in buzzword driven platitudes are the worst because they are inherently un-fixable. You can fix "wrong", but you can't fix "unclear".  Since there are so many possibilities with software the only way you can achieve clarity is through having an opinion and being able to describe/defend it. As an example, it was important to me that the system I designed be asynchronous from the beginning since I knew that we'd need to integrate with some slow external systems.  The opinion I formed is:

When the user clicks Save, their part is done.  The system should allow them to keep working and then notify them (if necessary) when the processing of their action is complete.

This led to a bunch of design decisions that wouldn't have been nearly as clear if I had a generic "the system needs to be fast" bullet point.

Be wrong early

You have your opinion and you start discussing it with others – your peers, your manager, your team, or whoever else will listen.  Be prepared to find out that you're wrong.  "Wrong" can come in a bunch of flavors: You've chosen a technology that's going to be difficult/impossible to get deployed, you've designed for a problem that doesn't exist, you failed to consider something that's critical.  The "be prepared" part means listening to feedback and watching reactions to find out that something could be wrong even if you're not being told exactly what.  It also means separating out general push-back from specific problems, especially from developers.  I once found myself in a surprising discussion with a developer over the design of my auditing strategy because he was worried that the database administrators wouldn't handle the data growth well.  Notice that that's a general fear that has less to do with the system (after all, auditing requires data growth by definition) and more to do with the environment.  We ended up keeping the design after discussing the various ways in which we could address data growth both with and without database administrator support.

Don't ship PowerPoint

If you're an architect, there is a strong possibility that you'll need to put your thoughts and designs into a slide deck to present to others.  This is a great exercise as long as you don't see it as your final deliverable.  The architecture I found myself designing needed to support several business units and perform a wide range of functions.  I had my opinions, I had my designs, but I didn't consider the architecture complete until I'd built at least a prototype.  In this case, that actually meant building the first module and I can tell you that things changed substantially from the time the paper design was done to the time we completed that module.  Even if you can't build an actual portion of the finished product, you should at least build a representative example of what you've designed and demonstrate that it exhibits the properties for which you've designed.

Know your environment

In the opening paragraph I noted that the advice was for people who wanted to build good software in a good organization.  If you're reading this blog, you probably have an idea of what "good software" is (i.e. meets user needs, can be extended, etc.), but you may not know what I mean by "good organization". The cornerstone of a good organization is honesty and most of the organizational problems I've encountered stem from a lack of honesty – anywhere from people kidding themselves to folks outright lying. In the context of development and architecture, you'll know you're in a good place if your opinions are met with open discussion and debate. It's surprisingly satisfying to have someone show you that you're wrong and then watch your design improve as you hash out a better solution together. You'll know you're in the wrong place if your opinions are met with silence, unproductive bickering, or passive aggressive avoidance. If you find yourself in such a place, then once again check out Driving Technical Change or dust off your resume and start to look around.  There are too many good places to let the bad ones grind you down.

WTF is Software Architecture?

It's one of those terms that seems to mean something different every time you hear it.  In the realm of consulting it often translates to "the most expensive PowerPoint slides you've ever seen".  My personal definition is:

"software architecture is the collection of hard-to-change decisions about a system" 

Decisions like whether to use an ORM, or an Enterprise Service Bus, or how security is going to be handled.  These aren't impossible-to-change decisions, but if you've ever been on a project where something of this magnitude was either overlooked or chosen poorly, you know that this kind of mistake threatens to sink a system.

What Does an Architect Really Do?

That depends on two things: The individual and the organization.  The problem with the title "Software Architect" is that there isn't a strong connotation of what will be delivered.  A "Software Developer" better deliver software.  A "Graphic Designer" better deliver designs.  A "Software Architect", however, has no corresponding delivery requirements.  This is left largely to the individual and it's then often left to the organization to decide whether or not to tolerate what they do all day value the role.

In the past 5 years, I've been fortunate enough to work with the full spectrum of architects and the full spectrum of organizational attitude.  My favorite type of architect is one who has a good grasp of how software fits into an organization, the technical ability to address the challenges, and feels a responsibility for the success of the developers who will be implementing the vision.  Former colleague Mike was a great example of this.  He know his stuff, had strong opinions on the things that were important to him, and always provided a reference implementation to show that his design was practical.  My least favorite type of architect is one who generates nothing but documents (PowerPoint being a favorite), dictates "how things should be", and then blames the developers when the vision turns out to be impossible or useless or both. 

But architects don't exist without an environment in which to practice, which is why organizations are almost as accountable for architect quality as the individuals.  The quality of the environment is more easily determined by what it won't tolerate than by what it encourages.  Sure, you want a place that encourages quality work and personal accountability, but that's not enough.  What separates the good from the bad is that the bad organizations will tolerate (or even value) the Big Talkers who spend days preparing for a presentation without ever once vetting the practicality of what they're proposing.  You probably know who I'm talking about, the folks who will show you super-complicated diagrams of their Service Oriented Architecture but can't answer a single question about how to version or end-of-life any of the listed services.  Casting things into "good" and "bad" is a little simplistic, though.  There are really 3 types of environments:

The Consciously Good Organization

These are the folks who have their act together.  Somewhere along the way, they've committed to creating first-rate systems.  If you find yourself in an environment like this, they'll likely have a really good architect who you can learn a lot from.  If you're brought into to be an architect in this type of organization, you are being brought in explicitly for the role and you'll have a good idea of what it means to succeed.  There is money to be made in a consciously good organization since they tend to pay for quality, but note that the competition for the role will be fierce and you'll have to be really good to land the gig.

The Cluelessly Bad Organization

These are folks who want to be good, but don't know how.  Or maybe they don't even know that they want to be good, but they have a feeling that things could be better and are receptive to ideas on how to improve.  Honestly, this is my favorite type of environment.  There is a lot of money to be made in these types of organizations because they are often leaving so much of it on the table with bad systems.  Not only is the money good, but the work will be very pure in that you'll spend much of your time showing them how things can be better and then implementing it.  If you are correct in your analysis and solid in your implementation then your work will easily pay for itself and you can continue until you've built them into a sustainable technology powerhouse.

The Delusionally Bad Organization

This is the danger zone, because these folks think they're good but they aren't.  Remember when I mentioned that you can more easily determine the quality of the organization by what they tolerate?  This is where that little nugget comes in handy.  The delusionally bad organization does some things well (and will point them out as evidence that they're "good"), but they tolerate mediocrity to the point where the good stuff almost doesn't matter.  The way you can tell the delusional from the clueless is that the delusional will actually know a lot about what it means to design and build first-rate systems . . . but then they won't do it.  Instead of building good stuff, everything turns into a messy collection of compromises that's explained away by factors beyond their control.  The good news is that there's money to be made in this type of environment because they will, in fact, need help.  The bad news is that they will make you earn every freakin' penny of it.  The work isn't really the work, the work will be trying to get things done in an environment that thinks it's okay even while things are crumbling around them.  You'll suggest a way of doing something, get told that it's not necessary, and then see the negative effects of not having it . . . all before lunch.

Is an Architect Role Right For You?

As you might imagine, the job of software architect isn't for everyone.  One of the best programmers I know has no desire to be an architect even though he certainly has the technical qualifications.  So how do you know if the position is right for you?  I think that before even attempting the role, you need the following:

• Wide technical experience with some pockets of depth – you should be able to build everything yourself, even though you won't.
• Network operations or sysadmin experience.
• Defensible opinions on how software should be built.
• The ability to convey complex ideas in simple language.
• Ideas about how software and technology can make organizations more successful.

Have I missed any big ones?  If so, leave a message in the comments below!

• What would you like me to do?
• How would you like this done?
• How should this be done?
• How should it work?
• Etc.

This may be the most value-robbing question ever.  It essentially turns an opportunity to show who you are and what you can do into nothing more than a task to be completed.  Asking what should be done is, essentially, asking someone to design the solution to the problem that you've been assigned.  When I run a team, I want my team members to design (and implement) the solution.  One of my management mantras is, "Bring me options and ask for a decision".

I can hear the naysayers now: "But Jay, not everyone who reports to me can design the solutions to the problems we have."

Oy.

I'm not suggesting that your only options are what your team brings you, I'm suggesting that before they ask for help they demonstrate an attempt at solving the problem.  This is how you build design skills: You practice and you find out where you're wrong.  Eventually you get to the point that your designs are accepted by your manager consistently and you get to move up a notch.  Without that practice, though, you'll remain stuck where you are.

So instead of finding out (and doing) what you should do, do what you can.  Present options to whoever needs to make the decision and if the options are unacceptable, then ask for help.  Look for the growth opportunity in everything you do and you'll be amazed at how quickly you grow.