Modern software development has evolved to become a very complex field. The technical work and “utilization time” of software developers to the maximum of their capabilities has become a key metric for software-driven organizations to leverage if they want to remain competitive and relevant in today’s landscape. More and more organizations are modernizing themselves and relying on software to power their businesses.
We will look into engineering developer productivity, by touching upon several interconnected aspects:
- Importance of developer productivity from a business agility perspective;
- How can software teams lay the land collectively to enable developer productivity;
- Main takeaways from the points discussed in the article;
Each of these individual topics will provide an anchor to introduce the next topic. When we look at these aspects from an encompassing perspective, a bigger picture will emerge and its main takeaways will be highlighted in the final section of the post.
Why Developer Productivity Engineering Matters
So, what exactly is developer productivity and why does it matter so much?
At its core, developer productivity can be defined as, in my own experience:
The combination of institutional processes coupled with a specific technology stack and technical landscape that in turn, enables software developers and teams to maximize the business value they can deliver for the organization.
The last point is, by far, the most critical one. Developer productivity is all about allowing your software developers to deliver the most value they can through their work.
This becomes very important for companies inhabiting the current business landscape, especially high-growth companies or startups whose main focus is to increase their market share fast to stay on the path of growth. One of the most efficient ways to do this is by delivering new features and being agile in responding to shifting customer expectations in a predictable and fast manner.
When developers are empowered by their organization and team leads to be productive, they can be a huge force multiplier in adapting to customer demands and delivering high value.
How exactly can this empowerment and productivity manifest themselves in practice? This will be the focus of what we’ll discuss next.
How to Achieve High Developer Productivity
In the following chapter, we'll take a look at developer productivity from three main perspectives:
- What developers can do to increase their productivity;
- Establishing or following established processes;
- Sitting at client meetings with relevant stakeholders;
Let’s delve a bit deeper into each of these topics and look at some established industry practices that can be followed here to increase your productivity as a developer.
Increase Your Own Productivity
First and foremost, increasing your own productivity through actions or processes that you can establish and control for yourself is the easiest way to get your value for money.
Examples of some actions that are useful to take in this direction can include:
- Block time in your calendar when you need to have focus time: Nobody else will take care of your calendar if you don’t. As the famous Product evangelist and coach John Cutler puts it, your calendar defines your priorities and nobody else will control it for you. When you need to really have focus time or define important meetings with certain stakeholders, you need to be the one taking control of your own time. It’s a very powerful yet simple idea.
- Focus on one task at a time: it’s better to do deep work in a single task for a long stretch of time instead of attempting to juggle potentially more shallow work on several other tasks that might incur in later technical debt.
By applying these two simple rules, you will be in a better position to both take better control of your own time. You'll make sure you're working on things that matter and that the time you put into these relevant things is well-spent in deep, focused and uninterrupted work.
Follow the Established Team Processes to Empower Developer Productivity
The second lens through which we will look at how to increase developer productivity is by zooming out from the single IC view and looking at the team and process as a whole.
Essentially, a team of software developers should strive to be set up for success.
By this, I mean that the existing tech stack and processes that are in place should always optimize for maximum local development productivity because the vast majority of the time of a feature is actually spent in the feedback loop of ideation - write code - add tests - acceptance validations -improvements are found. Then from these improvements, there’s a circle back to the ideation stage. This process repeats itself for a few iterations until the final feature can finally safely land in production.
Besides this optimization of the tech stack, there are also more general, ad-hoc practices that can enable developer engineering productivity in a way that extends beyond only the code and tech stack. Let's see what some of these practices are and then we will look into how to optimize the tech stack.
General Ad-Hoc Practices
Besides optimizing the tech stack alone, we can look at other potential optimizations outside the more technical side that are linked to the general process of the team and how the company itself operates. A list of these practices, along with the motivation for each of these, is presented below:
- Setting clear goals and expectations: it doesn’t matter how fast you’re going if you’re going in the wrong direction. Whether it's navigating your own career progression or finding an alternative solution to a tricky task at hand, having a north star guiding your efforts and an end-goal to strive for will supercharge your efforts by ensuring that the work you are doing is bringing you closer to your goal. When you have a goal and do the work in a single-minded manner to contribute towards that goal, you will be more efficient and will increase your productivity by getting where you want to be, faster.
- Documenting the approaches that work well within the context of your teams’ work and your own is a crucial step to increasing productivity. Some things are known to work well; others, not so much. Each organization, team, and person is different. With this diversity at play, documenting what works is important—like onboarding new colleagues or attempting to iterate on an already established process.
- Invest, as a mindset, into optimizing the enablers of developer productivity. Enablers are all the things that can increase developers' productivity from the perspective of ensuring that they can deliver the maximum value with the least effort. Putting these enablers at the forefront of the teams' and/or company's concerns should be a joint effort between multiple teams (operations, DevOps, developers, budget approvals, etc.). This can include automated production deployments, rollbacks, health monitoring, or tight integration between tools (think: Slack bot integrations, hooks, automated emails, etc.).
- The working environment is also critical. Even though COVID prompted a shift to remote work, this particular point leaves a bit up to each of us as individual developers. It is vital for developers to be able to do deep work without being interrupted when working remotely. That's why developers working from home should consider having a separate room or division dedicated exclusively to work.
- Regular 1-on-1 meetings between the manager and developer are also critical. These meetings are a two-way street for exchanging feedback. For example, developers can tell managers whether they like the work they are doing. At the same time, managers can gauge the developer's engagement and suggest redirecting their efforts elsewhere when necessary.
Tech Stack Optimization
Since the feedback loop described above can be a very long process, it’s crucial to optimize the setup, code, and infrastructure to make this process as smooth as possible in order to measure developer productivity properly. In my experience, this usually translates to having local environments that are as close to production as possible and having a good set of test data, as representative of production as possible.
The way I’ve seen this being achieved to near perfection in real-world setups is actually deceptively simple. Essentially, it's a three-way collaboration between code style, technology choices, and infrastructure (this can be a DevOps team, for example).
The main idea at a high level is the following:
- Your codebase needs to be in a shape where testing it in an automated way is simple and is the path of least resistance. For instance, architectures that favor containerization, decoupled deployments of services are preferred over architectures that don’t really enable it;
- Enabling an architecture that allows for containerization and usage of Docker as a way of writing tests, for example, allows developers to move much faster by having confidence that the code they are writing will interact in the expected way with its collaborator services when running in production. Since we can bring in the real services as containers into our test contexts, and then populate them with test data for test contexts, the reliability of our tests increases. As a result, so does productivity;
- Last but not least, having a dedicated DevOps team handling all the necessary plumbing and infrastructure to enable developers to work in this way is extremely invaluable. Its importance can’t be understated;
Looking at these aspects is key for enabling developer productivity.
Interact With Customers
Customer interaction is a special kind of “productivity hack” for developers that is not widely applicable (eg. depends on the business you’re in, the size of your organization, number of customers, etc,). In the cases where it can actually be applied, it can make a huge difference in the effectiveness of developers.
Because by talking to customers directly, developers now have a front-row seat to gather insights and knowledge from the people who are actually paying for the products that they are developing daily. That is a huge advantage versus being handed down requirements that have been proxied through several other stakeholders until they finally reach developers.
The closer you can be to the final customer, the more accurate your findings are. You will be able to move forward with much more confidence and purpose than you would otherwise be able to do.
Main Takeaways and Conclusions
Developer productivity is an important topic in modern software development. Throughout the article, we saw several points on how this productivity can be achieved from several different lenses, from an individual contributor to how a team communicates with their DevOps team and manages their pipelines.
The main takeaways are:
- There needs to be a productivity engineering culture embedded in the organization; no single person or team alone can increase or enable productivity. Productivity needs to be at the forefront of the values practiced by the company;
- Productivity can be scoped at many levels: if all levels are aligned, we can achieve the best results;
- Technology choices and code architecture play a huge role in enabling developer productivity;