In the tech industry, people have different opinions about this subject, that's a truth. But that won't stop me from laying out some of the things I believe a developer should care about and focus on, in order to be considered a successful developer.

This differs from the stage of the career that you are in, and shifting this priority is a sign of growth.

Juniors

Junior developers are just beginning their careers, and they lack the experience to have a deep business impact. In order to gain that experience, they are starting from the bottom of the knowledge pyramid, from learning the tools, the processes, how to interact with people, and they require a substantial amount of investment from their companies into their growth.

In the earliest stage of their career, their sole focus should be learning and nothing else. They shouldn't strive to become a high impact individual contributor, because they won't reach that stage until later, when they become a middle level developer.

At the beginning, their sole focus should be learning and acquiring as much understanding of the code, platform, processes and tools as possible. Asking and understanding why is the crucial step for this. And as a company, providing them the chance to do so and having somebody capable (and willing) to answer their questions will allow them to grow into a more useful role faster.

So to reiterate, learning, learning and learning. Understanding the why behind everything will yield a higher value than just finishing tasks without really understanding what is happening.

A thing I read recently, and I think is relevant here, is that bad programmers just accept magic . I think this is a phase where a developer should start digging into the internals of what they are using, being it a framework or a database, to better understand their advantages and disadvantages.

Middle

Middle level developers are the developers who now have some experience reading and writing code, and can be somewhat independent when it comes to coding. They can grab a ticket and finish it by themselves, not that they have a somewhat good understanding of the codebase, coding practices, tools and processes.

But they still lack an important skill: design. Their biggest challenge is coming up with simple, practical, extensible and elegant code.

They don't know just yet how to structure big features so that they can be as easily extensible as possible (to be frank, there are seniors out there who also struggle with this).

Therefore, as a middle level developer, you are now focusing on the code, and you need to make sure the code is up to standards. You will make architectural mistakes, bad data structure choices, etc, but you will gradually learn from them and hopefully your code will become more and more elegant.

I have found that, even if you have to write more code in the beginning, staying away from the most common code smells and mistakes will make your code way better than using the most elegant design patterns:

• small and clear functions and methods (maximum 5 parameters and not too many return paths)
• avoid the primitive obsession code smell (when you are overly using primitive data structures to represent domain objects, eg. representing a user as a [1, "email@example.com", "username"] list or tuple instead of having a User class to group that data).
• avoid the feature envy code smell (when an object does some complicated piece of logic business only by calling methods and getting instance variables on another object, which is a sign that that business logic should be in the second object, instead of first).
• avoid globals - it couples unrelated components
• write unit tests - if you are not writing tests for your code, you are dangerous to any team you are part of.

To reiterate, as a middle level developer, you should focus on the quality fo your code , meaning that you need to explore and incorporate design patterns where applicable, write simple and clear code and avoid code smells and over-engineering.

Senior

As a senior developer, you should be able to write good code, and your focus should shift from the code and towards the business. After all, software project are built to make money. And the sooner you understand and accept it, the sooner you will become a true senior developer.

If you are a senior developer and you still focus on design patterns, and you are willing to spend weeks and weeks on a single feature, just to get the perfect abstractions and achieve zero code duplication, I have some bad news for you: you are still a middle level developer, probably with more years of experience than the market average.

To be a true senior developer, your focus should be on delivering business value . That's it. That's not as sexy as achieving the perfect abstraction or using the observer pattern, but it is all that matters after all.

You, of course will be struggling with juggling the need to write good code, reduce technical debt and getting features and bugfixes out the door as fast as possible, but as a true senior developer, you will need to work within the given constraints whenever possible, decide whether it is worth spending a few more days working on that feature or if it is good enough to be shipped. Or if you can push it now and refactor later. Or if it will need to be refactored at all. Etc.

You will step into the business decision making domain, where you will need some difficult choices which will most likely clash with your core beliefs as a programmer: I want to write the perfect code, but I don't have the time and resources. I need to choose only two from quality, cost and time. Which one will it be this time?

You will need to become very familiar with who the users are, how they are using your product and what are the most critical parts of the app. Then you will need to learn to prioritize to maximize the business value.

Conclusion

To conclude, as a junior you should focus on learning , as a middle level developer you should focus on the quality of the code , and as a senior you should focus on delivering business value .