Where did all the developers go?


I am noticing a trend at Agile conferences. Fewer and fewer developers are showing up.

I guess I’ve noticed this for a number of years, but it really hit home recently at at a small American conference when someone commented on the lack of developer focused sessions, to which one of the organizers said: “We would add them except the developers never show up!”

What! I thought. That doesn’t make any sense.

Agile started with developers.
Developers (the ones I used to know) loved Agile.
Agile is software. How can you talk Agile without involving the people who create it?

So developers. Why aren’t we showing up at Agile conferences anymore?

Is it because we’ve been hijacked by Scrum professionals, certification wonks, vendors, and other ‘professionals’ who do everything but deliver software?

Is it because the Agile brand has become so diluted and meaningless that it doesn’t stand up for the things it once did? Like writing kick ass software and making customers happy?

Or is it because there has been no really innovations in Agile over the last 10 years and instead of catching up, everyone is falling backwards reverting to 30 day waterfall sprints under the umbrella of Scrum.

And to everyone else, does this even matter.

Does it matter that the people creating the software are no longer at the table?
Are Agile conferences no longer the best place to talk about innovating software?
And where will the next revolution in software delivery come from?

Where have the developers gone? Do we need them? And will they ever come back.

Update: Further comments can be found here on Hacker News.


The Agile Samurai Bootcamp


It is with great pleasure that I proudly pronounce the unveiling of my latest course: The Agile Samurai Bootcamp.


Based on The Agile Samurai book, this course is the perfect intro for people wanting to get into Agile, but unsure of where to start.

The course is super expensive, a whopping $25 (take that Scrum certification), and I challenge you to find a better introduction to Agile out there.

You can learn more about the course at here, but if you act now you can save 25% by clicking the link below:

I hope you enjoy the course.

Jonathan Rasmusson

You Can’t Plan Learning

1 Comment


A question I sometimes get from executives when I showing them where key insights, innovations, and breakthrough occurred on projects is: “That’s great. But why didn’t you just plan a little more and discover those before you started the project?”

I get where they are coming from. They want certainty in an upfront plan. They don’t want any surprises. And they want their software projects to execute just like the power plants and factories they’re use to building.

Except software doesn’t work like that.

You can’t plan the upfront learning that comes from iterating a product or service with a customer, and helping them discover what they really want.

Some customers can tell exactly what they want. But many others don’t. They know they have a need. But they don’t know what is possible, or how to get there.

It reminds me of this story about pottery making (from the book “Art and Fear”).

The ceramics teacher announced on opening day that he was dividing the class into two groups.
All those on the left side of the studio, he said, would be graded solely on the quantity of work they produced, all those on the right solely on its quality.

His procedure was simple: on the final day of class he would bring in his bathroom scales and weigh the work of the “quantity” group: 50 pounds of pots rated an “A”, 40 pounds a “B”, and so on.

Those being graded on “quality”, however, needed to produce only one pot — albeit a perfect one — to get an “A”.

Well, came grading time and a curious fact emerged: the works of highest quality were all produced by the group being graded for quantity.

It seems that while the “quantity” group was busily churning out piles of work-and learning from their mistakes — the “quality” group had sat theorizing about perfection, and in the end had little more to show for their efforts than grandiose theories and a pile of dead clay.

So by all means plan. But don’t count on planning alone to get you there. The best results come from building, iterating, and learning. And you can’t plan that.

The Agile Mindset


Agile has been around for over a decade, a lot of people are doing it, and that’s great.

But I see a lot of organizations struggling. Not so much with the tools and practices. But mostly in the mind – the head.

Here are a list of thoughts and attitudes companies need to get if they are going to truly adopt Agile as a means of delivery.

The plan is going to change

Plan the work, work the plan. That’s the mantra traditional project management has been teaching PMs for years. Except that it doesn’t work. Companies that expect software projects to be straight lines. But they look a lot more like this:


and it’s this unwillingness to change the plan that kills them – Agile or not.

Everyones has a plan until they get punched in the face. – Mike Tyson

Software projects are a bit like getting in the ring with Mike Tyson. They punch you in the face. And if you can’t take a hit, or are so tightly boxed in a corner that you have no room to maneuver, you are going to get knocked out.

Adaptive planning enables Agile teams to roll with the punches, take advantage of opportunities when things don’t go their way, and avoid much of the drama and dysfunction traditionally seen on projects that refuse to adapt.

So get used to changing the plan.

You don’t have all the requirements

Accept it. You don’t.

You might think you’ve got them all. You may read books telling you to gather them all before you start. But you can’t. Why? Because like Kent Beck once said:

The act of delivering software, changes the requirements.

Which means no matter how hard you try, you’re not going to have them all before you start. And the ones you do have are going to change. Just accept it and plan accordingly.

There is no change control board

This concept is so foreign to Agile delivery I almost cringe in bringing it up.

On an Agile project the only person who decides whether a feature gets implemented is the customer. They don’t need to seek anyones permission or approval. It’s their money. They can spend however they like.

Agile sides with the customer. If the customer wants a change, they can have it. Agilists believe this leads to better decisions, better products, and puts the responsibility for deciding how to spend the money where it belongs – in the hands of the customer, not the PM.

The cost of change isn’t high

Traditional thinking is that the cost of change on projects is high. That’s why this picture is still printed and promoted in modern project management bodies of knowledge.


This used to be true in software. But not anymore.

With the advent of the personal computer, just-in-time compilers, and phones with more processing power than older mainframes, we can make changes to software at extremely low cost.

We’ve also gotten a lot smarter. We have software engineering practices today that allow us to make changes with confidence at speed. That changes the game.

Instead of fearing and resisting change, you are now free to embrace it. And use it to your customers advantage.

There are no predefined titles or roles

Roles blur on Agile projects.

I know you have narrow, clearly defined, titles, roles, and responsibilities. Agile teams don’t care about any of that. What they do care about is doing a good job and removing anything that gets in the way.

So don’t get discouraged when your developers want to test, your testers what to be involved upfront in the analysis, and your Project Managers what to contribute and program. You are going to have happier people, most engaged teams, if you don’t limit them with a formal title or narrowly defined role.


You are going to fail

There’s a price to pay for all this progressive, initiative, risk taking way of working. You are going to periodically fail. It happens.

You can’t build innovative software or create great products without periodically going over the edge. Good companies will forgive you. The bad ones won’t. The good news is you get to choose which you would rather work for.

They are not requirements

Let’s think about this word. Requirement. It rings of something completely necessary. Something we absolutely must have.

So if we can deliver 80% of the business value from 20% of the requirements, what are the the other 80%? They’re not requirements. We didn’t need them.

Drop the word requirements from your software project vocabulary. It’s the wrong word. Instead use features, and treat them as things your software project may or may not have. Not requirements.

They are estimates

You know what an estimate is right? It’s a guess.

Guess how long it would take you to roll ones with a pair of dice. How long would it take you to find a missing card in a deck of cards.

Guess. Try it out. And then compare your actuals to your estimates. Think you are going to be within 10%. Care to make a wager on that?

The way we size software projects isn’t all that different. We estimate, or guess.

Except instead of treating these estimates as guesses, we treat them as commitments (and that’s where we get into trouble).

Agile estimates aren’t commitments. They are best guesses based on limited knowledge.

We turn them into commitments the only way we know how. By building something, seeing how long that takes, and then extrapolating that for the rest of the project (it’s not rocket science, but it works).

Working software is the definition of success

For a lot of companies getting projects in on time and on budget is the overriding definition of success. And Agile would agree that projects have to work within their means.

But rather put so much attention on the plan (which by itself does nothing) Agile takes that time and energy and puts it back in the one thing that does add value – the software itself.

That may sound obvious, but we deliver a lot of projects that are on time, and on budget, but deliver no value. It’s gotta stop.

Chaos is the norm

In 2004 Doug Decarlo wrote an article I really liked contrasting the different mindsets between the traditional and extreme (Agile) project manager.

Newtonian – Stability is the norm Quantum – Chaos is the norm
The world is linear and predictable Uncertainty reigns
It is controllable Expect surprises
We can minimize change We should welcome change
Add rigor to the process to increase the feeling of security Relax controls to increase the feeling of security
Deliver on the planned result Deliver to the desired result
Use the plan to drive results Use results to drive the plan
Aim, air, fire Fire, then redirect the bullet
Keep tight control on the process Keep the process loose
Manage to the baseline Manage to what’s possible
Get it right the first time Get it right the last time

I think this hits it bang on. You either believe everything can be planned, controlled, and thought of ahead of time, or you don’t.

Agilists think Quantum. And their practices, management and expectation setting techniques reflect that.

Three simple truths

Once you accept these three simple truths, leading agile projects becomes a lot easier.

You don’t stress as much about schedules (we know we’re already late!) You stop trying to own problems that are outside your sphere of control. And you just accept that there is always going to be more to do than time and money allow.

You stop taking things personally.

And software is personal. You put a lot of yourself into a software project, and it’s easy to take feedback, criticism, and things like schedule pressure personally.

But accepting these simple truths frees you from all that. It allows you to see that which is clearly, and to not try and change something that can’t be changed.

OK. That’s it for now. I plan on referring back to this article in the future, but I wanted to get some stuff out there on paper, so when when helping companies get better at software delivery, I can direct them here for a conversation starter, and then get to work.

OK – let’s talk.

Fresh Eyes

Leave a comment

Sometimes you get so close to a problem, or you are so intimate with it, that you can’t see how to go about it any other way.

No where is this more true than traditional project planning.

Traditionally, all that mattered to planners to was meet the plan.
On time. On budget.
Plan the work, work the plan.
That’s all that mattered.

There were very strong incentives for managers to do this.
They were paid to meet the plan.
Bonuses hinged on hitting the plan.

And this relentless drive to make the plan, is what has driven, and contributed to much of the drama and dysfunction we associated with traditional project planning. Especially in software.

Fresh Eyes

That’s why change never comes from the status quo.
It takes new eyes and approaches to see problems and solve problems.

It took a group of programmers, to stare down traditional project managers and say enough is enough.

If you have too much to do and not enough time, do less.

This is the basis for Extreme Programming and Agile Planning.
This is why we flex on scope.

Traditional project management is still grappling with this profound, yet simple insight.
They want to be Agile, and be seen as flexible when it comes to adapting the plan.
But they’ve got half a century of baggage and expectation setting slowing them down.

That’s why a revolution in project planning could never come from Project Managers.
They were too busy maintaining the status quo.

It took a group of engineers, with a healthy dose of common sense, to stop the madness, and bring sense back into the process.

XP is the Mac of Agile


When Apple released the Macintosh it changed the face of computing. Graphical user interfaces, drag and drop icons, clickable menus. Since its release, the personal computer has never been the same.

The same thing happened with the release of XP. Like an earthquake, it shook just about everything we traditionally believed and practiced in software delivery down to its core.

And then both failed.


The Mac got displaced by the cheaper IBM PC Junior.
And XP was pushed to the side by the less threatening Scrum.

In this article I would like to explore why Scrum has become so popular, the challenges this popularity brings to Agile, and why, like the Mac, I don’t think we’ve heard the last of XP.

Maintaining the Status Quo

One reasons I believe Scrum has grown so popular, is because unlike XP, it struck the right balance between maintaining the status quo and change.

The first version of XP was threatening. If you weren’t a developer or a customer, it wasn’t really clear what your role on an XP project was. With developers and customers joined at the hip, XP teams delivered at a speed and level or quality, seldom seen outside of startups.

(Note: In reality we did many XP projects with analysts and testers but I want to make a point, so bear with me).


But this speed and efficiency came at a price. It radically changed the status quo.

  • Testers felt threatened because developers were writing tests.
  • Analysts questioned their role if developers were speaking directly with customers.
  • And Project Managers were perhaps the most disrupted. XP trivialized their best laid plans, and had them embrace the one thing they had been trained to eliminate on all software projects – uncertainty and change.

Scrum on the other hand was different. Instead of insisting developers and customers sit together and build software, Scrum said: “Why don’t you guys form a team, and ship something of value every 30 days.” It didn’t say how to do that. Only that working software every 30 days was the goal.

This was music to the established players ears.

  • Analysts could analyze.
  • Testers could test.
  • Project Managers could PM.


I call this Corporate Scrum. Everyone could pretty much do exactly what they did before, but now in shorter 30 day cycles. Much less radical. Way more status quo.

Where XP alienated. Scrum embraced.

The challenge with Scrum

This of course lead to some challenges. Scrum is all about planning. It doesn’t talk engineering. This lead to a lot of Scrum teams doing the easy stuff (daily standups and Sprint planning), while failing on the hard (consistently delivering high quality working software).


Planning is easy. Delivery is hard.

And I think the Scrum community itself could do more here. Not highlighting, or actively promoting the XP practices around unit testing, refactoring, TDD, and continuous integration runs the risk of seeing the term Flaccid Scrum grow in popularity.

The Tribal knowledge of XP

And I think us XP’ers can do our part by sharing our stories and wisdom around practices like:

These euphemisms are too important to forget. And the spirit and technical excellence that contributed to XP’s early success will be necessary for Scrum too.

This is the beginning. Not the end

So while XP feels like the Apple Macintosh of the 90s, it would be premature to write XP off. Many of its ideas are only now becoming widely accepted. And many more are only just beginning to re-emerge.

It may never reach the heights today’s Mac, or displace the IBM PC Junior that is Scrum, but its influence and spirit are still being felt, and will be, for years to come.

Corporate Scrum


Corporate Scrum is a term I use for companies that do traditional Waterfall in 30 day sprints.


Instead of blurring the roles, and making things like quality a team responsibility:

  • analysts analyze
  • testers test
  • programmers program
  • and PMs project manage

There’s nothing inherently wrong with Corporate Scrum. For many it’s a big improvement, and a necessary first step into Agile.

But once teams get the basics of Scrum planning, they should look for opportunities to broaden their skills, and discover their natural abilities, and play more than just one role on projects (for example The Automated Tester).

The book that changed the game


I miss XP. It hit me hard how much when I read Uncle Bobs Ode to Kent’s White Book.


Man those were good times. We were going to change the world. It was us against them. It was the tyranny of the traditional against the brash, naivety of the new. And It was the programmers who finally stood up and said “Enough!”.

And man did XP make waves.
Test first? Ridiculous.
Recipes cards for requirements? You gotta be kidding.
Simplest thing that could possibly work? Grow up.

It’s unfortunate that people don’t talk about XP like we used to. But it’s practices are alive and well practiced everyday by thousands around the world.

Let’s take a look at why this book has so influential, the impact it’s had on our industry, and why we still aren’t all using it today.


XP tipped testing on it’s head.
No longer an after thought, left till the end, XP made testing the center of the universe on software projects
You didn’t write code until you had a failing test on XP projects
You didn’t check code in until all the tests ran
The tests needed to be continuously passing – 100%
You weren’t done, until all of your customers tests passed
Customers wrote tests. Developers wrote tests. Everyone tested on an XP project.


XP challenged a lot of what we traditional thought was good (upfront) design.
Taking more of an options approach, XP recommended not adding complexity until you absolutely needed it (YAGNI).


This was XP’s way of pushing back against the over engineering going on in the late 90s. XP taught us to design continuously (not once) while introducing us to the importance of language, and the power of a good metaphor.

Requirements & Analysis

The story card was XPs greatest innovation.
Instead of trying to get everything written down and get everything right upfront, XP said jot the idea down on one of your mom’s recipe cards, and have a conversation later with your customer if it ever comes up.
You wouldn’t believe the howls of protest.
How this could possibly work!
Where’s the tracability?
Where are the requirements?
How are you going to fit all those requirements on that one little index card?


1000s of books had been written on how to manage and plan software projects. XP pretty much blew them all up.
XP trivialized what it took to plan software project.
It punted on the whole ‘plan the work, work the plan’ thing by telling the truth (we don’t know exactly when we are going to be done), and rejecting static plans. Instead it said, we are going build something, see how long that takes, and then feed that back into the plan. Then we’ll tell you how are date is looking. No wishful thinking or management by miracle here.

XP was the first to suggest that when you have too much to do, and not enough time, you should do less. Rocket science. I know.


You can see where all this is going.
XP disrupted just about every traditional role on the software project.
It showed how dysfunctional things in our industry really were.
And not everyone appreciated that.
XP’s problem was it’s lack of inclusiveness.
It was great if you were a programmer or a customer.
But it was terrible if you did anything else.
It threatened testers (developers were now writing the tests)
It threatened analysts (developers were now talking directly to customers)
And it especially threatened project managers (small groups of professionals don’t require much in the way of management).

For these reasons many attacked XP and the Agile movement. And that might have been it if it wasn’t for the emergence and soft sell of Scrum.

Scrum to the rescue

For all of XP’s divisiveness, Scrum was the exact opposite.
Scrum was for everyone.
Small, self organizing teams made up of multi-disciplinary people delivering software every 30 days. Sounds great.
Traditional testers could test
Analysts could analyze.
Everyone had a spot at the table and was a large part why so many flocked to it.

PM’s were perhaps the most happy. Not only where the back in change. They finally had a means to ‘control’ these Agile projects, while simultaneously gaining a new title themselves – Scrum Master.

This was of course maddening to XPers and felt like a huge step backwards. Not only did Scrum not bring anything new or innovative to the party (from the XPers point-of-view). It completely left the most important parts out – the software!

But despite all these things, Scrum was hugely successful in one area where XP failed. Scrum was Agile’s beach head in enterprises and organizations.

Scrum made it safe for people to talk Agile. I am also extremely grateful to Scrum for promoting the concept of the self organizing team – no titles or roles on projects.

Ripples for years to come

Some to the largest organizations in the world are applying XP at a mass scale. XP had a huge affect on how Google tests software. And, not sure if anyone has noticed, Kent spends a lot of time these days at Facebook. I don’t know what the arrangement is, but that place reeks of XP. And for anyone who wants to see world class engineering and problem solving on a global scale check out how Facebook releases software or how they do development and deployment (hint – there is no QA department).

But love it or hate it, it’s hard to deny how much this book has affected our industry. Apparently it’s now recommending reading for management gurus. While on the other hand I know many in our industry would be quite happy to see it quietly die.

XP matters. This book matters, and many of us wouldn’t be where we are today if it weren’t for Kent and Ward. That book took courage to write. Let us hope we can show the same courage and continue talking about it in the future.

For more information checkout:
My recommended reading list (XP Books near the top)
The original IEEE Paper
Good ol Wikipedia

The Quantum vs Newtonian Belief System

1 Comment

In 2004 Doug Decarlo wrote an article I really liked contrasting the different mindsets between the traditional and extreme (Agile) project manager. I think this hits it pretty bang on.

Newtonian – Stability is the norm Quantum – Chaos is the norm
The world is linear and predictable Uncertainty reigns
It is controllable Expect surprises
We can minimize change We should welcome change
Add rigor to the process to increase the feeling of security Relax controls to increase the feeling of security
Deliver on the planned result Deliver to the desired result
Use the plan to drive results Use results to drive the plan
Aim, air, fire Fire, then redirect the bullet
Keep tight control on the process Keep the process loose
Manage to the baseline Manage to what’s possible
Get it right the first time Get it right the last time

The Automated Tester


Write. Code. Automate.

In the last couple of years I’ve seen a huge spike in demand for people who can write, code, and automate their own acceptance tests. I call these folks
automated testers. Not only do these people automate their own tests, they also do their own analysis and enjoy talking with customers.

In this talk I would like to explore the role of the automated tester, show how it is different than traditional Quality Assurance (QA), and share a few ideas on how to get there.

Software is eating the world

In his seminal article, Software Is Eating the world, Mark Andreesen makes a strong case for how software is taking over huge swathes of the modern economy and eating the world. Amazon. Apple. Google. Twitter. All these companies are building highly defensible, highly profitable businesses, with software at the heart of what they do.

This is great for the disruptors, but painful for the incumbents.

  • Amazon killed Barnes and Noble.
  • Netflix ended BlockBuster.
  • And AirBnb and Uber are redefining the meaning of hotel and taxi.

And it’s not just companies that are getting disrupted. It’s people.

With the rise of Agile, and the popularity of running projects with a more entrepreneurial startup spirit, traditional software development roles are being challenged. None more so than traditional QA.

Everyone is a tester

Today everyone is a tester.

  • Analysts test.
  • Developers test.
  • Designers test.
  • Customers tests.

Everyone tests. Quality is no longer the sole domain or responsibility of a single group or entity. It’s a team responsibility. And that’s a big change for the traditional tester. Everyone is in their house.


This wouldn’t be a big deal if testers could show up on a project, be given a well written spec, and then be left alone to create comprehensive test plans to be executed every time someone changed the software. But those days are gone.

That role doesn’t exist anymore.

So if analysts are testing. And developers are testing. What’s traditional QA doing?

Leveling Up

I see two options. Traditional QA can dig in, defend their turf, and fight for the mantle of sole custodians of quality (in other words try to keep the status quo). Or they can branch out and get into analysis and development they way BAs and dev’s have gotten into testing.


To do this, the trick is to stop viewing analysis, development as testing as siloed roles. These are things that need to be done. Who does them doesn’t really matter.

I know many testers who are wonderful analysts. They bring an attention to detail and outside the box way of thinking that’s invaluable in flushing out requirements and necessary for doing thorough analysis.

I also know testers who are great at automating their own test cases. I don’t mean simple click and record playback bloat ware. I mean actually getting into code, using open source frameworks like Watir, Selenium, Cucumber, and RSpec.

By expanding their skills and getting into these other areas testers can quickly become doubly valuable on projects. Not only can do their own analysis and write great acceptance tests. They can code them up, verify things work, and reduce their reliance on developers for automation.

Shorter queues. Fewer handoffs. Less waste. More value.

Don’t let yourself be limited by yesterday’s job definitions.

Enter The Automated Tester


This is where the automated tester comes in. These are testing experts with a passion for business and a thirst for automation.

They like knowing the business because it helps them write better test cases. And the more they automate, the more time they have for edges cases and exploratory testing.

They also like technology because a good understanding of the tech gives them insight the limits and capabilities of their testing frameworks.

The experienced ones know they can’t (and shouldn’t) automate everything. Every test has a cost and they think carefully about what to automated. They also work closely with developers to to see what unit tests the developers have written and make sure they aren’t duplicating effort.

And of course they still love exploratory testing. Automation is fine. But it’s not perfect. To truly be effective you still can’t beat the intuition and creativity that comes from firing up the browser, clicking through the app, and looking for ways to bust things along the way.

Getting there

Now if all this sounds easy – I assure you it isn’t. This is a tough, demanding role. You’ve got know the business. You’ve got to have a passion for automation and technology. And you have to enjoy continuously learning and retraining yourself.

But it’s a huge opportunity. It’s an invaluable role and one I think we are going to start seeing a lot more demand for in the near future.

Here are some ideas on how to get there.

1. Build apps.

You don’t have to be a developer. The goal is to get just deep enough to understand at a high-level how things work.

If you are testing web apps, you should know how HTML/CSS and JavaScript work. If you are building iPhone applications, you should have XCode and be really familiar with the emulator.

Did you know, that if you build a simple app holding a table with some numbers from a database, you’ve basically replicated 99% of the business applications being built today!

Building simple apps and understanding the technology is going to give you insight. Insight into how these testing frameworks works, their limitations, and where they need to be abandoned.

2. Master one testing automation framework.

There are a lot of automated tested frameworks to choose from. Don’t sweat it. Just pick one. Learn it really well. Then move onto another.

They all work pretty much the same, and once you’ve got one figured out they all work pretty much the same.

If you are testing the web, start with Selenium. Then try Watir, RSpec, Cucumber, or whatever else your team likes. If you are on the iPhone try Frank. The framework doesn’t really matter. Just pick one and go.

3. Hug a developer.

A good developer can be your best friend. The good ones are already doing what you getting into and the best will be more than happy to show you how it all works. They can set you up, help get you going, and even augment the frameworks you are using by making them easier to use.

Study what they do. Learn how they set things up. And soon you will be able to do it on your own.

4. Automate everything.

I know I just said the good tester don’t automate everything before their eyes, but in the beginning you should try, just to get the practice and see what’s possible.

You are going to write a lot of bad tests when you first start out. Don’t worry about it – we all do. Just automated everything you can, and you’ll soon start to get a feel for which tests add value, which ones don’t, and where to draw that line.

5. Fear nothing.

It’s going to be scary when you start (I am talking to you traditional QA testers). You are going to be leaving a space of traditional, comfort, strength, and responsibility, and entering something completely foreign and new. I’ll let you in on a little secret. It’s like this for everybody.

Developers go through this every time they learn a new language. BA’s go through it when learning a new business domain. And PMs go through it when they drop the Gantt chart in favor of the burndown.

You have nothing to fear. Everyone is going through it. Just be humble. Ask for help when you need it. And you will fit right in.

One challenge


One challenge of becoming an automated tester is people are going to look at you a little bit funny. Companies don’t like things that don’t fall neatly into slots, and you are going to be an anomaly.

You are going to go to conferences, explain what you do to people and they are going ask:

So are you a analyst, tester, or developer?

Conferences, papers, titles, pay scales, expectations, and bodies of knowledge are not going to be ready for you. Nobody is expecting you to work like this. We’ve got 50 years of history working against us. But it’s like that for the pioneers.

All I can say is hang in there. Do whatever feels right. Start slow. Start fast. Look for the opportunity and seize it when it comes.

In the meantime practice, be prepared, and keep taking on more responsibility. Once you demonstrate the value this role brings (through action – not words) project managers will soon be getting into fist fights for your services, and you’ll have the freedom to contribute however you wish.

Remember the goal isn’t to test or even build great software. It’s to build something wonderful for our customers. And you are just doing whatever it takes to make that happen.


There’s a new role for testers out there. One that blends the art of traditional testing, with analysis, development, and automation.

If you have a passion for testing, are curious about technology, and are looking for more ways to contribute to your project, consider becoming an automated tester. It’s an exciting role, one that every Agile project needs, and one I hope we see a lot more people entering in the near future.

Older Entries

%d bloggers like this: