As all dev managers, including ourselves, have witnessed, the last few years have been characterized by unprecedented and rapid technological advances. Due to this, there has been a fundamental change in the way applications are being developed. The software world as we knew it shifted from monolithic app development to new methods such as microservices architectures, cloud functions, and distributed systems that are faster and more agile. These, and other similar processes, have accelerated the speed of development, fundamentally changing the way applications are developed and communicate with each other.
While this evolution has brought a myriad of advantages - such as creating new businesses, new capabilities, and even helped organizations to produce more value - there are still significant challenges that come with managing this change and the developers that have created and maintained it.
Being a manager is a challenge in and of itself, but when it comes to managing developers? That’s a whole different ball game. Not only do you need to be able to handle a wide area of skills in a dynamic environment, but you also need to be responsible for a variety of applications and resources and have the ability to manage strong personalities. As if that weren’t enough to deal with, the job also includes day-to-day management like task planning and prioritization, development cycle management, versions publishing, bug management, meetings, and so on and so forth. It’s kind of a very long list.
So, with all of these challenges, how do you ensure that your devs are being their best dev selves? Well, apart from the right tools, a lot of their success lies in their having a great manager. And having a great manager? That part lies with you. In honor of the new year, we’ve put together three key action items that we've found the best dev managers do. So grab that glass of champagne and sip away as we cheer on being the most kickass dev manager of 2021!
Establishing a relationship with and gaining the trust of the engineers you’re managing is a key way to establish yourself as a successful dev manager. As with everything good in life- much like a plant- your team needs to be cared for and nurtured. Or in this case, invested in.
Without a team that’s willing to listen to you, not only will you not be able to get anything done, but you’ll also lose your developers. Because let’s face it- who would want to stay in an environment they’re not happy in?
So how do you establish this relationship in actuality and ensure that your team is operating at their best?
Start off by making sure that you invest time in identifying bottlenecks that are affecting your team. This clears obstacles in their way and makes sure that they have the most advanced arsenal of tools available to them. This helps to win their trust and when your team trusts you to take care of them, together you’ll be able to achieve much more. This type of investment always pays off.
Once the bottlenecks have been identified, take a deeper look at your devs’ tools. Arming the team with great tools will place you as a tech leader that pushes for innovation. Using the best tools has many positive impacts. These can range from your devs avoiding frustration, becoming more efficient, solving issues faster, all which translates to higher productivity levels.
Try ask yourself: can I give up on my current tools or processes (such as CI/CD pipelines or advanced monitoring tools) and still be able to do the job? In most cases the answer is a resounding YES. But, if we’re going to be honest with ourselves, you won’t actually end up doing that. These processes and tools save you time, effort, money, and ultimately make your team perform significantly better.
Using the right tools is not just an investment for the developers you’re managing, it’s also an investment for you. While that may seem contrary, it’s because managers always need to find the ‘sweet spot’ between bugs and new product features. Fixing bugs makes your customer happier, but it’s also slowing down your team from writing more code to enhance the product features, and you as a manager need to perfectly balance between them.
Thinking about debugging microservices or cloud functions in production environments always makes me think about one of the things that excites me the most: fighter jets. A fighter jet has many moving parts and systems that need to work together in real-time in order for it to be able to fly. When there is a malfunction in mid-air, the pilot has to be able to understand the root of the problem in the shortest possible time, all while the plane is in the air in the middle of a crisis. Sounds terrifying? It is. And software debugging really isn’t so different. It’s a complex and hard to scale process, especially when done in restricted environments, such as production.
In the upcoming year, with all these flying components, your developers are the pilots that need to be able to pinpoint an issue as quickly as possible with the least amount of effort, all while their code is in flight (or running live, to use the precise terminology). For example, in case your team faces a code related issue, live debugging is exactly what you need. Live debugging the platform that has the bug can save a significant amount of hours for your team by minimizing the time spent on code changes, rebuilding, and going through CI/CD just to get more data.
Yet, all of this is just the tip of the iceberg. Live debugging can also allow you to generate logs on the fly if needed, thus meaning that your developers won’t need to try and reproduce that issue elsewhere.
As a manager, you’ll often find yourself facing the dilemma of how much time to invest in resolving bugs and how much to keep for new features. It is clear that while new features generate new value, bug fixes preserve what you already have. Deciding between them is always difficult and a decision that you’ll find yourself needing to make on a daily basis.
Fixing bugs faster means money being saved and more time being freed. This then translates to your team having the ability to take on new tasks that create more business impact, such as new product features. And all of that together leads to more value for your organization.
The bottom line is that when your devs are using the right tools, you won’t have to make the difficult choices of choosing one or the other. Contrary to what you’ve been told your whole life, you can actually have your cake and eat it too.
Oftentimes engineers lack the data necessary to understand what’s happening in their code and don’t have a simple method to get that data. They frequently find themselves at a crossroads, faced with the dilemma: do I develop the task ahead of me with the information I already have, or do I develop a feature that will get me more data? This is just one of the many dilemmas and challenges that software engineers face on the daily, and as a manager, you’ll need to find the solution for.
This is where software understandability comes into play. Essentially, it means that an application can be effortlessly understood by developers, whether it’s those who created it or those who join along the way. This is achieved when developers at all levels are able to make updates to it in a way that is safe, clear, and predictable.
Understanding your remote environment is very important, and it’s very different from local environments. If you attempt to do so by closing your eyes and walking blind, you’ll find it is quite difficult. Deploying an app to a remote environment is one of those times that developers are faced with this choice and are in need of understandability. They are giving up on some senses - such as their debugger - and use other ones - like metrics, monitoring, and logs - to gain some understanding of what is going on. However, in actuality, none of these capabilities really gives them visibility into how their code is doing while everything looks like working.
As a dev manager, it’s important that you help your developers reach this fundamental level of understanding of how the whole app is performing. This means that they’ll understand how each part (i.e. function, specific line of code) works and are able to figure out issues before they happen.
Live debugging will not only make it easier to debug an app when an issue occurs, but will also allow you to routinely analyze the application and understand it’s behavior. By incorporating this into your pipeline, you’ll ensure that your team isn’t moving blindly through their code.
Managing a team of developers has very little to do with dealing with coding and much more about dealing with, well, basically everything else. As a manager you have the ability to push your team forward by using the right tools and being a tech leader. Pushing for innovation always creates better processes, improves efficiency and velocity, and keeps your team at the forefront of technology. When you look back, you will see all the changes you made and all the tools you added for your team and will see how they improved their productivity and the quality of their work . As a leader, always remember that leaders create great developers and great developers build great products.
So no matter which choice you make, always make sure that your devs are the top priority. Wishing you a happy new year from us and looking forward to seeing what this new year brings you, manager-style ;)