My Biggest Regret As a Young Developer

Being a coding genius is only the start. Master developers immerse themselves in the entire software lifecycle.

Software development is not just coding but also designing, analyzing, deploying, testing, monitoring, and maintaining.

The best software engineers recognize that overseeing every step of this process is crucial to a successful product.

My biggest regret as a young developer? Neglecting the broader spectrum of software development.

Once, I worked in a team with several senior developers who saw themselves as 'coders' only. They were unwilling to work on deployment pipelines, help debug UI bugs, or help with the UI test tools.

Software developers think they create code and push it to git, and that's the end of work for them.

This is not how the team is supposed to work. Developers should learn about the CI/CD pipelines testing process analysis, deployment, monitoring, and maintenance.

We had one DevOps guy who was responsible for setting up the CD/CI pipelines. He helped testers set up test deployments, supporting several pre-production and production servers and overseeing deployments everywhere.

As the team and project grew, he was responsible for many tasks related to monitoring, performance, and maintenance of the various servers.

He was overworked and the constant bottleneck for the team.

The developers were unwilling and/or unable to manage their test and deployment environments. Testers also relied on that one guy to repair everything for them.

We needed to change.

We switched our approach. The developers learned how to prepare and monitor their CD/CI pipelines and test servers. They also helped testers to monitor and set up their test servers. Developers were also involved in the maintenance and monitoring of the pre-production and production servers.

This allowed the DevOps guy to focus on more critical tasks in the production.

The rest of the team was empowered and knowledgeable about other aspects of the development pipeline. Developers were able to set up and manage different server configurations. They could also fix the problems faster because they managed their whole pipeline from coding and deployment to testing and monitoring.

Do not think that you are paid to produce the code as quickly as possible

This is all far from the truth. And even if you are in the team that is measured based on the line of code they produce, run away.

Aside from the fact that this metric can be easily gamed, it is a totally wrong way of measuring anyone's productivity.

There are a lot of activities that precede coding and follow the coding. The important thing is to realize that the end of the process is the product that the customer can use. This is all the stakeholders are focused on.

Even if you are the best coder under the sun, it will not help if your code does not serve the customer.

You can learn a lot from other roles in the pipeline. Ensure that the product is successful by knowing more about the whole process. This way you don't need to wait for other roles in the chain to help you, and the process is more streamlined.

If you can handle the problems that span the bigger part of the organization, you put yourself in the position of a leader.

Adopt a holistic approach

The senior developers are seniors, not because they produced the code for 20+ years. They are rewarded for the broader, company-wide perspective they can bring. Yes, they are great coders, but that is only the start.

The development process is teamwork and requires different roles to produce great results.

Recognize that if you want to affect the outcomes, you must know more about every step of that process.

This will give you multiple perspectives and lenses for looking at the problem. With this perspective, you can solve so-called 'coding' problems differently, not by code.

Here is what will happen when you do not recognize that a problem is happening at a different step of the process:

• Analysis: Before you start coding, it's crucial to understand the problem you're addressing. If this phase isn't understood, you might build a solution nobody needs.

• Design: Here, you draft a blueprint. If you skip or misunderstand this phase, you might end up with a fragile structure, poor user experience, or even security vulnerabilities.

• Coding: If you only focus on coding without context from the previous stages, you could write code that's inefficient, not scalable, or even irrelevant.

• Testing: If you don't grasp the importance of this phase, you risk releasing software riddled with bugs, which could lead to user dissatisfaction, financial loss, or even legal issues.

• Deploying: If not done correctly, you might face downtime, data loss, or even security breaches.

• Monitoring: Not understanding this phase could result in undetected issues, leading to prolonged downtime or unhappy users.

• Maintaining: If you neglect this phase, your software could become obsolete, riddled with issues, or incompatible with newer systems.

A holistic approach will lead you to:

• Career Growth: Understanding more than just coding can lead to roles like system architect, engineering manager, or even a CTO role.

• Versatility: Employers love developers who can wear multiple hats. Understanding these facets makes you more valuable.

• Quality Products: If you understand the complete lifecycle, you will likely build robust, user-friendly software.

• Improved Collaboration: When you get the bigger picture, you can communicate more effectively with team members from other disciplines.

P.S. Here is another article you might find useful: https://beyond-coding.beehiiv.com/p/type-coding-counts-increased-pay