This article has been originally posted on my blog. If you are interested in receiving my latest articles, please sign up to my newsletter.

It's an awfully mainstream question nowadays that who should a company keep or whom it should let go. The question stands firm from the other side as well. What is a fair selection? Why me? Or if you are luckier, why him and not the other one? What shall I do - differently - in the future to stay on the top of the pack? What attitude will keep me safe in times of adversity and recession?

Even if laying people off is not happening in certain companies, the above questions can quickly come up in virtual coffee sessions. What we started discussing a few weeks ago with a colleague was autonomy. This time, not the missing cultural and political one of many ethnic minorities, not even your coveted financial autonomy, but rather the degree of autonomy of an employee.

You are capable of performing your defined tasks

If you don't give a lot of thinking to this question, you can simply say that well, nobody is coding for the other. We can all do the coding for ourselves. We are autonomous software engineers, aren't we?

While this is hopefully true after the first few months for everyone, it is also a very simplistic view of the question as that is just the first level of autonomy. Something that you should really expect from everyone. It doesn't mean that you can't ask questions, but you should be able to perform your activities without constantly keeping someone off his own work.

You receive a task, a user story, where the problem is well-defined, as well as the definition of done. In the team, you have a common vision of what and how has to be done. After all, that's how you sized the task. In such circumstances, you're able to deliver it without someone else's supervision and constant help.

This is the first level of autonomy.

You can find your way to deliver a solution

Between the first two levels, there are no fundamental differences, yet one step higher on the ladder of autonomy, you don't need the team or you to already know how a solution has to be delivered. Given a problem and the desired outcome, you can find your way to get there.

For example, you are told that there are two functionalities in your system that interpret the same data in different ways, whereas only the first one is correct, but nobody knows how and where the data manipulation and the display are taken care of. You are given this situation and you find your way out of it. Don't think that this is insane. It's an everyday problem in huge systems.

When we say that "no one is coding for someone else", is either the first or the second level depending on how we get to the solution.

You become the problem finder

When you reach the next level of autonomy, you leave behind the image of someone who can only follow orders in order to deliver a solution. You become someone who identifies the problems to be solved.

You might not be able to provide a solution right away, or just simply don't have the mindset of spending time on finding possible solutions before talking about the problem with your managers, but at least you can identify problems in complex situations and you can share with even non-technical stakeholders in an understandable way.

It's like you realize a potential issue in a business flow, but you only share what the problem is, you don't go beyond proposing a solution at the same time. I know how this is going to sound but think about people who only complain about things and don't propose solutions instead. I bet you could name a few such fellows. They are important - unless they just complain really about everything - but they haven't reached their best selves yet.

You give solutions not only problems

The ultimate level of autonomy when you don't just approach the stakeholders with problems, but depending on the efforts required, you actually go with either a solved problem or possible different solutions.

Hey, Bruce, I found that we might have a serious vulnerability in our enhanced product. Fixing it will require a few days, but there are possible solutions. Do you half an hour so I share our options with you?

You see, how much better this is than just saying that oh we have a problem that must be solved? (By someone else than me...)

By the time you reach this level of autonomy, believe me, you'll be among the most valued contributors of your organization. From someone who could follow orders, first, you became a problem solver - which is such an important role - then the solution itself.

Conclusion

Today, we briefly discussed the 4 different levels of autonomy you can show in your job. While the difference between levels, in the beginning, is mostly about technical skills, later it's less a question of coding skills, but it's rather an attitude.

First, the question is rather something like, can I declare a class without pondering 5 minutes about how should I do it. Then after it evolves into meaningful very legit technical questions, it more becomes something like, do I walk around with open eyes and recognize problems? Do I take the liberty to actually fix what I find important? Do I trust myself enough to say that what I think is important is actually important and is it worth doing/fixing it? Do I just share/complain that something is bad, or I go there, I fix it and in case I rather ask for forgiveness than permission?

I think the second level is the bare minimum you expect from anyone after a few months for most of the tasks (unless some architectural decisions are needed), but beyond that level, there are fewer and fewer people. Of course, the average level of autonomy depends on the company culture as well, but there is only one person responsible for your level of autonomy. You guessed it right, it's you! But that's a story of another day.