In a world with an ever-increasing amount of tech jobs and an equivalent amount of tech workers, it can be hard to stand-out as a software developer and become successful. Successful software developers work on the coolest projects in dynamic environments; sparring with architects from different teams, advising product owners about strategic choices. If these are things you enjoy in your work as a software developer, it’s time to take matters in your own hands and start focussing on habits that will make you stand-out!

Ok, you are past first base: you are motivated and ready to start. So, what are the qualities, skills and habits you need to master in order to become a successful developer? Of course, the answer varies depending on who you ask; a fellow developer, a SCRUM master, product owner, or an IT manager. This article focuses on the habits of successful software developers. Habits don’t require extensive study of theory, just intention in how you act. The habits in this article are derived from opinions of myself and colleagues in various roles (developer, architect, project manager, CTO). Beside these habits, skill, knowledge, and experience is required to be a great developer. However, I believe these six tips are a great foundation that you can build on. Focusing on developing these habits in your day-to-day work will get you set for success!


It is no coincidence, openness is one of the five key points of SCRUM. Openness is a habit that applies to many areas of your work as a software developer. It applies to the way you approach colleagues, listen to users, how you receive feedback and how you view new technical challenges (hint: they are opportunities!). That makes openness one of the most important habits to master as a software developer. Always be open about what you know and what you don’t know. Not knowing things is not a weakness, rather it’s an opportunity for learning.

… to Users and Stakeholders

While speaking with users or stakeholders, construct a mental model of your application, envision how your users interact with it, what their goals are, and what they expect from it. Your mental model should be closest to the actual reality, not your perception of reality. Openness in your interactions with users or stakeholders will help you to build an accurate mental model of the application. Empathize with the users of your application and validate your viewpoints with them. You need to recognize your own prejudices and bias(es) and take nothing for granted. It is better to have the obvious confirmed than to make faulty assumptions.

… to Feedback

Code reviews and feedback are an integral part of the development process. As developers, we are blessed with this continuous feedback. It is a tangible way to learn from and with your peers. Some people may feel hurt by feedback, interpreting it as critique or even act defensive. This attitude will inhibit their ability to learn. Remind yourself to be thankful that the reviewer takes time to review your work and provides you with points to improve on. Use it to your advantage! Of course, it helps if the code reviewer takes the effort to give constructive feedback, Michaela Greiler has published an interesting article to get started with that: Respectful constructive code review feedback.

#5: Experiment and be curious

I strongly believe curiosity is the main pillar of software development. Curiosity probably got you into this job in the first place! Most of the software developers I know had a habit of taking apart all kinds of household appliances when they were kids, figuring out how they work. Others wanted to learn how to build the video games they loved to play. Nurture your curiosity and let it drive you to learn new technologies, libraries, languages, design patterns and ways of working. Successful developers don’t wait for somebody to tell them what’s new in the latest version of their favourite language. They are the ones reading the release notes, trying out beta versions, and sharing that knowledge enthusiastically with their colleagues! There is something new to learn every day. So even (or especially) when you have been working in the same environment for a long period of time: never stop experimenting and exploring.

#4: Show interest in business goals

Make sure you deeply understand how your code, or even better, the application you are working on helps to reach business goals. If you are not sure about these goals, find people that can explain the business goals to you (usually the product owner). Understanding your clients’ business goals will help you to make well-founded functional and technical development choices. Getting it right from the start will save valuable time, thus making you more effective. Once you’ve gained a true understanding of the business goals, make sure to apply this knowledge not only in your technical work, but also in meetings such as refinements and sprint plannings. If the product owner suggests a new feature that appears to be in conflict with what you understand to be the business goals, discuss this. This will either help to refine your understanding of the business goals or it will highlight an actual conflict that was overlooked. Keep in mind business goals can (and will) change, so keep validating your knowledge. To acquire a good understanding of the business goals it is useful to acquire domain knowledge early in a project. Having profound knowledge of the domain is often a characteristic of senior developers on projects; combined with their technical competence it allows them to accurately assess the impact of critical choices.

Also, in my experience showing genuine interest in the goals of your clients is a great way to establish trust and build a strong professional relationship.

#3: Improve continuously

IT is a very fast paced market with lots of new or improved technologies being released each month. To become and to stay successful you will need to keep up with those developments. Therefore, one of the most important competencies of successful developers is self-directed continuous learning.
Here are some things you can do to keep developing yourself:

  • Follow bloggers/vloggers in your field of expertise (and preferably just outside of it as well).
  • Attend (virtual) events and conferences.
  • Regularly visit the official blogs of the languages and frameworks you use to check if new features are announced.
  • Regularly browse for new frameworks/packages you could benefit from in your projects.
  • Speak with your colleagues about code and new tech.
  • Experiment, experiment, experiment.
  • Read books (e.g., “The Clean Coder” or the “Pragmatic Programmer”).

Also, there is nothing more energy draining than repetitive tedious tasks. They will consume valuable resources you could otherwise spend on productive activities that will help you grow. So, work smart and automate your work when possible:

  • Learn about IDE’s keyboard shortcuts and refactoring features.
  • Use CI/CD pipelines for running unit tests, linting, deployment, etc.
  • Write automation scripts and use git hooks.
  • Document complicated processes so you only have to research them once. You can share the document with others and save time explaining it.
  • Be alert on any improvements you can make in your day-to-day workflow.

Finally, share your (newly) acquired knowledge! There is nothing more motivating to get to the bottom of a topic than knowing you have to tell your peers about it later. Additionally, thinking of ways to explain difficult matters will spark a deeper understanding within yourself.

#1: Get comfortable being uncomfortable

Finally, a habit about actual software development! Developing software requires resourcefulness, since you have to come up with innovative solutions for any problems you encounter. However, don’t reinvent the wheel. Instead, use what knowledge is available: numerous bright people thought long and hard about best practices for common problems. This is especially true for more abstract coding principles, design patterns and software architecture. Make sure to adhere to those principles (like DRY, SOLID, Clean Code, Design Patterns) and relevant coding style standards but be creative in your implementation of functionality. By doing this, other developers (and your future self) will better understand your code and can easily change or extend it.

While designing your software, factor in that you will probably not be able to get it right the first time. This is no problem, as long as you keep things simple, reiterate on the design, and refactor your code regularly. Every now and then, take a step back and reflect on what you are doing and how it fits in the bigger picture. It is unlikely the same solution or architecture works for two different projects. Be pragmatic, focus on what you know and keep those things simple.

#2: Innovate, iterate, but don’t reinvent the wheel

Software development is a continuous learning experience. Even if you have been working on the same project for 10 years, new challenges will require new skills or knowledge. The realisation that you do not have certain knowledge or skills can be immensely unpleasant, making you feel insecure. Trying out new a new IDE, new languages, or frameworks can make you feel awfully uncomfortable, as you find yourself struggling to accomplish even basic tasks. Effective software developers embrace that discomfort as they know, it helps them grow.

“You can only grow if you are willing to feel awkward and uncomfortable when you try something new.” Brian Tracy, Motivational Speaker

Think about all you learned from developing that new complicated feature that you did not know how to implement when you started. Or the pride you felt when your first application ran without errors after struggling for days. Looking back, why did you persevere through the struggle? Probably because you enjoyed learning new things, fixing small parts of the puzzle with each step you took.

But I can’t…

If you are blessed with a hint of perfectionism, getting out of your comfort zone might seem impossible. It helps to focus on things within your control. In my opinion, it helps to focus on the process instead of the result. For instance, if you want to write perfect code, the best way to improve to that level is to:

  1. Write a lot of code.
  2. Get feedback: submit your code to a strict reviewer who will point out all the errors and missed opportunities to you.
  3. Fix all the remarks.

Repeat those steps A LOT of times and you will probably write flawless code. Next time you find yourself deflated because your pull request is rejected, please consider you are actually perfectly executing the process of becoming an excellent coder!

What’s next?

Some of these habits should become part of your work mentality, while others may require you to invest some spare time. However, in a healthy SCRUM process “spikes” facilitate time for research and experimentation with new technologies. Often before starting with a new project or feature, there is some time to research and experiment as well. Now you know these 6 habits, incorporate them in your day-to-day work where possible and start living and working with them in mind:

  • Be open to your colleagues, stakeholders and users, ask them for feedback!
  • Experiment with new technologies and frameworks and talk about your findings with other developers!
  • Stay on top of the business goals (and how they change)!
  • Continuously improve yourself and your workflows!
  • Use industry best practices and innovate!
  • Get out of your comfort zone!

When you are learning, experimenting, or maybe trying out these habits and you find yourself far outside your comfort zone remember: the only place to learn how to swim is in the water, not on dry land!

Met duco sparren over jouw carrièrepad?