Top 10 developer productivity tools

Selecting the tools that can deliver maximum value is crucial for keeping software development teams on track

March 20, 2025

Ready to start?

Top 10 developer productivity tools

Editor's note: This blog post was updated 20 March 2025 to include all new developer productivity tools, including updated features and comparison points between similar tools on this list. To reflect the changes we've seen in the market, we also included tools focused on software engineering intelligence, developer experience, and govenance/task management to better address all aspects of developer productivity.

Introduction

We know that developers have many routines to follow. They participate in dailies, prepare estimates for sprints, write code, perform code reviews, handle tests, deliver to production, and manage incidents. Developers juggle so many different tasks each day that they lose between six and 15 hours per week navigating up to eight different tools, according to our 2025 State of Internal Developer Portals report. 

This is work — and time spent — that has nothing to do with coding, and it has an impact on overall productivity. Developers may struggle to deliver features on time as a result of tool sprawl, which can cause bottlenecks and potentially derail the entire team or roadmap. Sometimes, developers just want a way to remove barriers that are preventing them from doing what they do best: write code.

Pairing developer productivity with developer experience

Measuring developer productivity is a hot topic right now. Even with DevOps practices in place, developers will always need to learn something new or ask for assistance with unfamiliar tasks. This increases the cognitive load on both developers and their DevOps teams, keeping devs away from writing code. 

On the other hand, these challenges with new tools or unfamiliar tasks are complicated further by bad user experiences. In our inaugural State of Internal Developer Portals report, we found that developer experience — how the developer may feel when using a certain tool or framework — also has a high impact on productivity and efficiency. 

This is where the need to pair developer productivity — getting more done and delivering software faster over a given time period — and developer experience — the actual sentiment developers have about their workload and how it impacts their ability to achieve goals, feel successful, and contribute meaningfully — becomes clear. 

Top 10 developer productivity tools

When compiling this list, we included a variety of tools across software engineering intelligence tools, developer survey tools with custom reporting features, and more traditional developer productivity tools to capture the full range of available options you have to boost, measure, and improve developer productivity. This is built on the understanding that well-supported, nimble developers will be more productive.

Here are ten of our top picks (in no particular order):

1. Port

Port is an internal developer portal, a unified platform that integrates with all of the tools your engineers currently use across your entire software development lifecycle in a single, better developer experience. Port unifies engineering intelligence with developer experience, so you can both identify the issues creating bottlenecks and improve them, all in one.

According to Gartner, 85% of organizations with platform engineering teams will be providing internal developer portals to their engineers and developers by 2028 to help streamline this heavy cognitive load and boost both developer experience and productivity in one fell swoop. Rather than adding another tool that will only increase your sprawl, an internal developer portal gives you a better option: uniting your tools in one place and helping you pave the way for true productivity and efficiency.

Port’s features include:

  • Engineering 360: Survey your developers from within the portal, and use their feedback to leverage the portal’s features like self-service actions, initiatives, and scorecards, to drive meaningful change throughout your SDLC. Then, use dashboards to track your progress against DORA metrics and other engineering KPIs.
  • Standards: With your DORA metrics tracked and developer sentiment accounted for, use scorecards to define standards, communicate them, and force certain requirements like documentation before deployment. Initiatives help you track the adoption and compliance of your teams across projects.
  • Self-service actions: Let developers take faster and more independent action with self-service actions. Ensure developers follow golden paths by baking them into the workflow.
  • Software catalog: The flexible software catalog lets you bring your own data model. This means it reflects your organization exactly and provides a searchable database for the entire SDLC, from services, APIs, and events, to users, teams, and access control relations. Developers can use the portal’s software catalog to gain visibility and understand what’s actually going on in the platform.
  • Integrations: Integrations are what power the portal — and with Port, you can bring in whatever you’re using in your tech stack and get started right away. 
  • Access control: With fine-grained RBAC, you can dynamically administer the proper permissions to developers by team, project, or role within the organization.
  • Workflow automation: Automate your engineering workflows and business logic. Build approval workflows into the portal to enable faster async work, and place conditions on workflows by role.

{{cta-demo-baner}}

2. DX

DX is an engineering intelligence platform, the crux of which is developer surveys. DX’s main focus is providing a platform for developer sentiment data-gathering and analysis.  It does not provide a holistic view of the entire developer experience because its focus is on making recommendations for cultural improvements, rather than offering a set of tools to improve developer experience.

DX’s features include:

  • Experience data: Experience data enables automated developer surveys and the timely collection of self-reported data. The challenge with self-reported data is that it may be biased and is easily gamified, depending on the methodology used to conduct the survey and the way in which platform engineering was introduced. For example, if developers are concerned about their performance data being used against them in performance reviews as opposed to used to inform real problems in the SDLC, they may self-report in a way they think will inoculate them from this potential.
  • Data lake: The data lake acts as a layer between your data sources, like GitHub and Jira, and your data warehouse, like Snowflake or Looker Studio, and organizes information about your SDLC. Unlike an internal developer portal, the data lake is only able to serve as a data organization tool, rather than a tool that helps you translate data into actionable workflows. 
  • Benchmarking: DX’s research arm offers insights you can use in Benchmarking to determine how your organization’s metrics and standards compare to others. This helps put your data into context so you can identify risks and opportunities, but leaves out a built-in place to take meaningful action to improve, which means introducing additional tools to achieve continuous improvement.
  • DX AI: This is a GenAI tool that makes it possible to query the data in your data lake. It also acts as a data scientist, helping you create visualizations, presentations, and narratives to support your strategy to implement changes. Like the data lake, however, this tool’s usability is limited to the data it has access to.

3. Jellyfish

Jellyfish is a software engineering intelligence platform that integrates with your existing toolset and organizes metadata from across your pipeline into actionable insights. It is primarily geared towards engineering managers who are looking to push their teams closer to the business. As a result, its focus on developer productivity is secondary; you will still need to buy or build separate systems in order to address the findings and deliver better, targeted experiences..

  • Engineering management: This platform within Jellyfish focuses on helping engineering managers and CTOs focus their teams’ effort on business outcomes, monitor software delivery, and gauge team health overall. With an emphasis on advancing operational maturity, this part of the platform can deliver top-down changes, but leaves out developer sentiment.
  • DevFinOps: Similar to focusing developers on business outcomes, the DevFinOps tool offers FinOps managers and business intelligence analysts insights into their developer teams’ performance, efficiency, and overall costs. This provides teams with the opportunity to think strategically about roadmapping efforts and expenses alongside one another.
  • DevEx: This survey feature makes it possible to gather insights from your developers and segment their sentiment data by team, tenure, and project. 

4. Swarmia

Swarmia’s engineering intelligence platform is aimed at engineering managers who want to deliver better business results and tie engineering projects to revenue. Its developer productivity features are aimed at speeding up delivery times and developing better internal practices to improve DevEx. Its limitations include a lack of customizability, a lack of comprehensive integrations which lead to an incomplete picture, and surface-level insights rather than digging deeper into root-causes and potential actions to take to improve on the insights.  

  • Business outcomes: This area of Swarmia’s platform is geared towards engineering managers who are interested in proving the value of the software delivery team and infrastructure to the overall business.
  • Developer productivity: This feature is built for managers looking to create a set of workflows that help remind and notify about SLAs, keep teams on track and on pace, and increase visibility into individual workloads. While this platform helps make it easy to drill down into individual workflows and issues, it’s less functional for cross-workflow or cross-project analysis.
  • Developer experience surveys: With surveys, managers can collect and analyze feedback from developers to better understand what needs fixing and how to improve it. The platform also makes data more visible to survey participants, encouraging them to discuss changes. But the platform cannot make recommendations or enable you to build or change existing workflows to improve performance.
  • Data platform: Swarmia’s data platform is configurable and integrates with your existing toolset. As data evolves, users can make small changes to address issues with data quality as they arise. But, similar to DX’s data lake, Swarmia only integrates with tools like Jira, GitHub, and BitBucket, which leaves out a significant amount of engineering data that could be crucial to identifying developer pain points.

5. Cortex 

Cortex is another internal developer portal offering several features to improve developer productivity. As a portal, Cortex is aimed at improving developer productivity and experience, but is built on top of a strict data model that can limit its success. 

  • Catalog: The catalog includes documentation, change history, dependencies, and ownership information and keeps all data updated for each software component. The frequent challenge for companies is modeling their unique environments and processes fully within Cortex without writing custom integrations and organizing the hierarchies yourself.
  • Scorecards: Cortex scorecards are tightly coupled with the catalog, with the intention for you to set requirements for software and teams and track progress. But the proximity scorecards have to the catalog also pollutes the data model, making it difficult to define outcomes for production readiness and migrations.  
  • Eng Intelligence: Cortex’s engineering intelligence capabilities are tied to scorecards for enforcement and require careful monitoring of specific teams and data sources to drive change. Compared to other platforms listed here, this setup requires more attention to detail and manual analysis of different metrics to be effective; other options can do this for you.
  • Scaffolder: The scaffolder is essentially a library of project templates and static, boilerplate code files that teams can use to speed development. You can connect them to scorecards to ensure requirements are followed and new code introductions trigger fewer change failures. 
  • Workflow automations: These multi-step workflows let you chain together unlimited actions across all connected tools and teams. 
  • Developer homepage: Straightforward, the developer homepage reduces devs’ need to shift between tools for information and taking action. You can offer teams a personalized experience that can help teams get to work faster, regardless of their specific responsibilities. 

6. LinearB

LinearB is an engineering productivity platform that helps teams monitor their deployment pipelines. DevEx engineers can report on developer productivity, measure experience quality, gauge standards compliance, and more. But LinearB lacks any features that unite the tools and processes across your SDLC which limits the ability to streamline actual developer processes — instead, its primary focus is on observability and governance. 

  • AI & workflow governance: LinearB can help you understand the ROI of the AI tools you’ve adopted and control access to systems the same way you would human developers. This reduces the risk of bad AI-generated code being introduced to production without proper review, context, or security controls in place. 
  • Software engineering intelligence: LinearB’s SEI platform increases observability across teams. It is geared towards engineering managers whose primary needs are to report on metrics to leadership, clear data bottlenecks, and identify project uncertainties that may cause delays. But it lacks any features that would enable managers or platform engineers to take action to fix these issues natively. 
  • Developer experience: DevEx engineers and teams can use this part of the platform to help define production pathways and SLAs, enforce compliance with pull request policies, and report on productivity and engineers who are falling behind.. This also powers performance reviews for developers by providing managers with insights for new learning opportunities, language or skill gaps, and more, which may improve retention.

7. Backstage

The only open source software on this list, Backstage is the original internal developer portal framework. While its primary benefit is that it’s open source, which may conjure images of endless flexibility and possibilities for your engineering team, it is not a holistic SaaS solution for developer productivity the way some other tools are. 

With an uncustomized Backstage instance, you get access to three core features, which we discuss below, and the robust plugin ecosystem, through which you can power a multitude of different experiences to boost developer productivity.

  • Software catalog: Like the others on this list, Backstage’s software catalog comprises an organized, searchable database of your microservices, libraries, versions, ML models, and more. Its underlying data model is rather strict, with fixed entity kinds and fixed relationships between entity kinds which means the software model cant model everything you want to model, thus not showing the SLDC as it really is and not providing the right context to developers when they need it. 
  • Software templates: Software templates is an engine designed to perform self-service actions. You can also use templates to standardize tooling, security requirements, or other best practices to ensure whatever developers build follows your organization’s standards. However, a broader range of self-service actions, such as day-2 operations, are nearly impossible to implement directly through Backstage. 
  • TechDocs: This feature makes it easy to create documentation for all of your software components in a friendly docs-as-code approach. But it doesn’t offer scorecards or initiatives, which play a crucial part in governing the security and production readiness standards your teams will need to continuously improve and deliver better software.

{{reading-box-backstage-vs-port}}

8. Harness

Harness offers a developer experience and software delivery platform that has some additional features focused on developer productivity. Harness’s solution-oriented platform focuses on providing teams with secure software pipelines, efficient DevOps practices, and a good developer experience. 

But Harness is also built on top of Backstage — which means all of Backstage’s drawbacks also apply to Harness, with the exception of a few custom features. Rather than discuss individual features, they group multiple features together into experiences:

  • Modernize DevOps: This part of the platform primarily serves DevOps engineers, with many different features focused on CI/CD, GitOps, feature management, IaC management, and reliability. 
  • Secure software delivery: Rather than perform security checks at a later point in review, Harness bakes security into the delivery pipeline to ensure testing is complete and effective.
  • Measure and improve DevEx: Automations, organization tools, and engineering data can be found in this section, which is focused on helping platform engineers identify bottlenecks in the SDLC, assess team productivity, and improve planning.

9. Atlassian Compass

Atlassian’s Compass platform is built to integrate with their suite of other engineering tools like Jira to deliver a more portal-like experience. Its features are very decentralized and focused on developer experience, which makes it more difficult for managers to use as a data source for drawing insights into developer experience, but still offers some benefits for gauging productivity.

  • Catalog: The catalog in Compass is designed to reduce the cognitive load on developers navigating among many different tools, services, and scenarios. It offers a component overview that includes any relevant APIs, libraries, docs, and deployment activities related to each service. It also maps dependencies and activity among components, to provide better visibility. However, it cannot incorporate cloud resource data, or add parameters and relations berween services.
  • Health: This includes scorecards, which are used to codify development standards, a team dashboard for tracking owned components, and what Compass calls “CheckOps,” which allows teams to improve performance with retros informed by engineering data.
  • Extensibility: With many common integrations available, Compass also offers Forge, an open source framework for building custom integrations so that you can include any data you want, from any source, in your portal.
  • Templates: Encourage developers to follow golden paths with templates, which offer preset information and requirements based on scorecards to speed development. You can also use templates to automate repetitive tasks.

10. Datadog

Though Datadog’s software is quite different from an internal developer portal, it offers several disparate features that, when combined, can offer an ad-hoc experience similar to those found in SEI tools. The downside of using Datadog as an ad-hoc portal is that the data within is less easily organized or used to determine developer productivity as it would be in a portal or SEI tool.

There are two main Datadog feature groups that can compare to portals and other developer productivity tools:

  • Software delivery: This includes CI management, test optimization, and continuous testing capabilities, which offer teams more consistency and control over the outcomes of tests, security of their new code introductions, and streamlined delivery processes. 
  • Service management: Service management includes the software catalog, app  builder, incident response, workflow automations, and event management features of a portal. 

Wrapping up

Developer productivity may be a buzzword many engineers are wary of, but there are many available tool options to choose from that can enable the experience you want to deliver. Whether you’re a platform engineer building the platform or a manager trying to get a better handle on your DORA metrics, the portal experience you need is closer to fruition than you think. 

{{cta-1}}

Tags:

General
{{survey}}

Download your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical walkthrough of Port

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta-demo}}
{{reading-box-backstage-vs-port}}
{{cta-backstage-docs-button}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Starting with Port is simple, fast and free.

Let’s start