3 strategies for consolidating your toolkit and boosting productivity

Developers are a company’s biggest asset, and productivity only helps to meet business goals. In fact, research from our 2021 State of the Octoverse report shows that developers are almost 60% more likely to feel equipped to do their job when they can easily find what they need. (See more stats and insights in our 2022 report.)

Today, enterprises have access to many different tools to get the job done. This doesn’t just include languages and frameworks, but extends to the productivity tools that you and your teams use on a day-to-day basis. In some cases, enterprises may be paying for different tools and solutions with the same functionality.

For engineering leaders who face the challenge of keeping developer productivity and the overall developer experience top of mind, we’ve identified a few important factors to help retain existing talent, and also attract new talent to your organization.

In this blog post, we’ll explore some of the common challenges with a diverse set of tooling, and steps that you can take to identify and consolidate them.

The challenges of a complex tooling landscape

As businesses grow and priorities change, it’s common to adjust strategy to fit the business need. In some cases, this may also mean adopting additional tools to help get the job done.

However, as more and more tools are adopted, complexity increases. Not just from an integration perspective, but also from a business process and productivity perspective. We all know that feeling of flipping through different tabs and programs just to finish one task. The act of context switching not only distracts us, but takes away precious time from the actual project.

When this happens, it takes around 23 minutes to get back to the original task, according to Gloria Mark, Professor of Informatics at the University of California, Irvine. Imagine how much time is wasted flipping through tasks because developers need to switch among tools.

This means that defining, maintaining, and provisioning development environments becomes harder, and developers have to spend more time context switching between different tools and less time writing code.

An increase in tools can lead to complexity and silos

Siloed teams are likely to impact innovation and creativity. In some cases, different teams may be attempting to solve the same problem separately, without even realizing it.

That’s why having a centralized platform is so important: it’s one place that empowers developers to do their best work together.

Scaling technology teams in a cost-effective manner remains a challenge. Developers can solve really complex problems, but to enable this, you also need to provide a healthy team environment which enables them to get into their flow state and deliver their best work.

Organizations need to tackle the challenges of process and technical resource coordination in order to empower developers to deliver on projects and provide that rich developer experience.

For growing engineering teams to thrive, the right solution is needed—one which enables both easier collaboration to scale quickly and an asynchronous work schedule.

You may be paying for the same, or similar functionality in multiple tools

Consider the tools that you’re using in your organization today. You may have a mix of open source tools, along with tools that are being paid for based upon a licensing agreement or subscription model.

As organizations grow and evolve, tooling needs evolve. In some cases, teams are empowered to make their own tooling choices, while some teams are mandated to adopt a centrally purchased tool.

In either case, there may be scenarios where multiple tools provide the same, or similar functionality. In the current economic environment, budgets continue to get tightened. This sprawl of tooling can lead to a hidden financial problem—waste.

Waste can come in several forms, including:

• Duplicate costs for tooling which provides the same functionality.
• Programs and tooling, which may not be used, due to multiple tools delivering a similar experience.
• Friction in the developer experience for developers, leading to confusion on which tooling to use.

These are all factors which can be explored to enable cost saving, while improving the developer experience and positively contributing towards innovation and the team environment, rather than budget cuts which would take away from that experience.

An optimal developer experience

At GitHub, we believe the developer experience is critical to making sure that software engineering teams are productive, successful, and happy. It’s why we built tools like Codespaces and GitHub Copilot, and continue to research how these tools are improving the lives of developers.

To keep developers focused on learning and long-term growth, GitHub can act as one solution to simplify your technology stack. It provides tools for automation, and creates workflow efficiencies with an interface that developers know. By reducing complexity, increasing transparency, and anchoring on a central platform, GitHub gives developers the ability to focus on what they do best.

Strategies to reduce technical complexity and increase productivity

You may be asking, how can we get there? How can I ensure that my organization is not paying for unnecessary tools, so that developers are spending their time on what they do best? As with any migration or project, this type of transition will take time. Our recommendations will help you get there.

To complete any migration, you first need to have a solid plan (fail to plan, plan to fail!). You need to have a clear understanding of the current state and your endgoal. You can build this plan by cataloging your tools and grouping them based on capability.

Depending on the maturity of the tool environment, there are generally three steps to reaching an optimized state.

1. Catalog your tools

While this may sound simple, this is an important step to understand what tools you currently have. Depending on the size of your organization and number of tools, this may actually be one of the most time consuming parts of this process.

Thankfully, understanding and documenting the tools could be started as easily as creating a spreadsheet and starting from an existing list of tools, in partnership with other development teams and relevant groups to complete the list.

Going through this process will help identify duplicate tools, existing contracts, and help make license usage across the organization become more clear, manageable, and actionable. As a result, this will save time and money for future work.

2. Group tools based on the capability

Another benefit of understanding the tools you have is achieving a state with a minimal amount of moving parts. If tools are cataloged, it will be easier to group tools based on their capabilities and highlight overlaps.

If this step is followed, the tools environment will have the minimum number of moving parts while remaining fully functional and multiple tools providing the same capabilities can be removed, saving money and management costs.

3. Integrate tools based on capability; continuously integrate and simplify

At this stage, the tools have been cataloged and grouped by capability. You could say that we’re now entering a state of continuous improvement. Based on your prior assessment, you’ll want to iteratively integrate tools so that they are loosely coupled with each other. Some tools you may wish to retire, or continue to optimize over time.

Tools that are integrated based on loose coupling means that changes to one tool should not adversely affect the other. For example, if there is an integration between a testing and backlog tool, replacing the testing tool should not require major configuration changes to the backlog tool.

Continuous integration is a development practice where work is integrated frequently and there are reduced integration barriers. This practice can be extended to the tools environment where the flow of work and value is frequently moved from tool to tool with little to no barriers.

This is the last step that we recommend. By integrating tools based on capability, you will have a much more simple tech stack that interacts and flows as one. Achieving a simplified and optimized tooling environment creates a stronger environment for your development teams, major cost savings, and a seamless administrative management process.

How GitHub Enterprise can help consolidate tooling and improve developer experience and productivity

While ‘success’ varies by organization, delivering projects on time, automating more tasks, and creating team environments where developers get to solve problems they care about (and that impact business outcomes) opens up the pathway to meeting strategic goals consistently for the long-term, and enables more innovation to happen!

A study alongside Forrester on The Total Economic Impact™ of GitHub has shown that teams can achieve a 40% reduction in developer onboarding time, save 45 minutes per developer per day, and provide a significant opportunity for cost saving.

Centralizing on GitHub means that your engineering teams will be adopting fewer tools, which reduces context switching and will improve the developer experience, leading to productivity gains. In many cases, this will lead to a reduction in developer onboarding time, as developers are familiar with GitHub from their personal projects, open source contributions, or time studying as a student.

Improve developer experience and productivity

At GitHub, we are able to meet developers where they are: on a platform they already know and love, which is imperative when it comes to attracting and retaining top talent. As you build your team to take your technology and business to the next level, choose GitHub Enterprise as your long-term partner and let the experimentation and innovation begin. After all, GitHub is the #1 ranked DevOps platform on G2 for a reason!

As an end-to-end centralized platform, GitHub Enterprise encourages collaboration, empowers developers to build productively (while prioritizing developers’ happiness), and accelerates high-quality software development and delivery without sacrificing security.

GitHub Enterprise provides a solution that ties to the entire development lifecycle; a holistic environment where developers can excel, teams work together, and projects get delivered.

All of this leads to improved time-to-market, revenue growth with reduced cost of hardware and admin time, improved customer satisfaction, and a much better developer experience.

GitHub fits into the entire development lifecycle:

• With GitHub Issues and Projects, requirements can be defined and work can be prioritized.
• In an organization where transparency and openness is encouraged, open source principals can be re-used to remove silos and facilitate code contributions to GitHub repositories across the organization by using pull requests.
• To make contributions across programming language and team boundaries easier, Codespaces can be used to provision a development environment within seconds to minutes, supercharging your engineering team to be even more productive.
• GitHub Actions can be used to ensure the software being produced is high quality. One of the 15,000+ actions from the GitHub marketplace could be used to integrate with your existing tooling to bring it into your development workflows.
• GitHub Packages can be used to share reusable libraries and packages across the organization for developer efficiency.
• Dependabot can be used to raise pull requests—keeping your project’s dependencies up to date, while highlighting the critical issues that may pose a security risk to your project.
• GitHub Advanced Security’s code scanning capabilities can be used to regularly check the security posture of the code your teams have written. You can choose to use CodeQL (GitHub’s native semantic code analysis engine), or integrate with third party tools that output Static Analysis Results Interchange Format (SARIF) data. The results will all be available, directly in the GitHub repository, next to the code your engineering teams are writing.

We know that reducing the number of tools required also reduces the time it takes new hires to become productive and lets developers focus on writing code rather than managing tools.

From minimizing context switching and simplifying the tech stack, to increasing collaboration and saving time through code reuse and automation, GitHub Enterprise leads with the developer experience in mind—and helps engineering teams stay secure throughout every step of their workflow.

Written by

Chris Reddington

@chrisreddington

Mark Paulsen

@mjpaulsen