Developer experience (DX) tools are critical in boosting your team’s productivity, innovation, and satisfaction. With the right tools, your developers can write great code faster, collaborate better, and automate some of the more repetitive mundane tasks.
Being software engineering consultants we have a unique perspective on how different developer experience tools work with our client’s tech stacks. We have gathered a collective experience of our engineers and prepared this list of 9 developer experience tools that our clients and their developers found helpful.
The list is in no particular order, as there's no way to name one tool as significantly better than another; it's all about which tool is better for a specific project. However, from point five onwards, we are focusing on tools for projects powered by the Scala programming language.
Why should you work on your team’s Developer Experience?
The selection of tools we present is designed to improve the Developer Experience (DX) of your team. While DX might initially seem abstract, merely connected to job satisfaction, there are tangible business reasons behind it.
Enhancing your team's DX allows your developers to operate in a streamlined environment without unnecessary complications. They can then focus on writing code, solving real-world problems, and achieving their objectives more quickly.
1. Strapi: A Seamless CMS Solution
Strapi is an open-source headless CMS that simplifies backend development by automatically generating APIs, based on content models. Whether you're creating websites, mobile apps, or APIs, Strapi empowers developers to manage content effortlessly.
Why do our engineers recommend Strapi as a tool for a better developer experience?
We’re big advocates of Strapi—not just because we specialize in Strapi headless CMS consulting, but also because it powers our website.
- Eliminates backend complexities.
- Automatic API generation from content models.
- It’s highly customizable and developer-friendly.
2. Sourcegraph (Cody): Smarter code navigation
Sourcegraph elevates code navigation with powerful search and intelligence tools. It enables developers to find and explore pieces of code across repositories, saving time that would normally be wasted on manual searches.
Which features of Sourcegraph make it stand out?
Sourcegraph integrates with popular version control systems, boosting team productivity and collaboration. It has three features that are directly improving the developer experience.
- Code search across multiple repositories.
- Jump-to-definition and find-references functionality.
- Contextual code suggestions for smarter development.
3. Vercel: a tool for effortless frontend development
Vercel is a cloud platform optimized for frontend developers. It simplifies the entire lifecycle of web applications, from deployment to performance optimization.
How Vercel improves Developer Experience
By prioritizing automation and ease of use Vercel allows developers to focus on creating exceptional user experiences. Our engineers named some of the features that are particularly good at that.
- Automatic deployments with GitHub, GitLab, or Bitbucket.
- Instant previews for live updates and feedback.
- Comprehensive documentation and no-configuration setups.
4. Bazel: a powerful build automation tool
Bazel is an open-source build and testing tool tailored for large, complex projects. Its focus on scalability and efficiency makes it an ideal tool for modern software engineering.
Bazel supports multiple languages and offers flexibility and extensibility, enabling developers to customize and extend its functionality.
Why do our engineers recommend Bazel?
We have witnessed firsthand the versatility of Bazel. As a result of Bazel migration for one of our clients, we were able to simplify their project setups by creating a Bazel IDE. It was a customized integration that acted as a command-line utility. For other projects looking to improve their developer experience, we recommend relying on some of the key features of Bazel.
- Native support for remote execution and distributed builds.
- Built-in caching for faster development cycles.
- Multi-language and cross-platform compatibility.
We recommend Bazel for projects involving monorepos or diverse build environments, as well as for C-based projects, where Bazel facilitates cost reduction while improving reliability and consistency.
5. Pulumi (Besom): Infrastructure as Code with Scala
Pulumi lets developers define cloud resources in their preferred programming languages, which elevates infrastructure as a code approach. For Scala developers, the Besom SDK enhances the experience even further.
Why Pulumi is worth recommending as a developer experience tool
Our engineers named three main reasons why Pulumi is a great developer experience tool.
- It’’s free and open-source.
- Supports AWS, Azure, Google Cloud, Kubernetes, and others.
- Besom SDK brings Scala’s functional programming strengths to infrastructure management.
6. Scala CLI: a simplified Scala workflow
Scala CLI simplifies compiling, running, and packaging Scala code, making it an essential tool for Scala developers. It’s a command line-focused tool that tries to bring the simplicity of interpreters together with some more advanced features, which you would normally only find in a larger build tool.
Scala CLI is now the default runner for Scala 3, and it is distributed together with its artifacts. It is also included in the language installation by default, so if your team has Scala installed, they have Scala CLI as well.
Why Scala CLI is one of our recommended Developer Experience tools?
We recommend Scala CLI for scripting and prototyping projects, partially thanks to Scala Toolkit initiative that promotes a set of simple libraries for rapid prototyping. It has other advantages as well.
- Support for Scala.js, Scala Native, Graal’s Native Image, and JVM, as well as IDEs such as Metals and IntelliJ.
- Quick switching between Scala and Java versions.
- Easy tool configuration directly in the source files.
Our engineers also highlight Scala CLI’s ability to manage and automatically download all of the required library dependencies, as well as the necessary JDK/JVM versions and other tools.
Scala CLI can run any Scala class or script, replacing the need for build tools such as sbt in smaller projects. Configuration can be directly embedded within the input source files through functional code comments known as using directives, which are placed at the beginning of the file. For example, comment //> using scala 3.5.2 specifies the Scala version to be used.
7. Scala Metals: A lightweight IDE support
Metals is a lightweight language server for Scala. It offers robust IDE features without the weight and complexity of a full IDE. It allows for more advanced features such as refactorings, debugging, or worksheets.
Why Metals is one of our favorites?
Language servers such as Metals follow the Microsoft LSP specification and it allows them to be connected to any editor that supports the same protocol without the need for a dedicated plugin.
- It’s compatible with multiple editors, including online ones.
- It has most of the IDE features without being one.
- It enhances productivity while being fast and lightweight.
- It supports all the new Scala 3 features.
Metals has the best support for the features in the latest versions of Scala. It can identify and display the same errors that the Scala compiler would find during the process of compiling the code.
Metals has also a rich community of users with maintainers being able to quickly and efficiently fix any potential bugs.
8. Scalafix: Automated code refactoring
Scalafix is a tool for Scala developers looking to enforce a consistent code style and migrate between Scala versions. It allows users to verify chosen rules in continuous integration and IDEs.
Why Scalafix is a great Developer Experience tool to use in 2025?
Our engineers have named four reasons why Scalafix is an excellent developer experience tool for our clients' projects.
- It detects and fixes common code issues using a rich suite of rules.
- Facilitates seamless version migrations between library and Scala versions.
- User can create their own rules to lint or rewrite their code.
- It can be run from most of the existing Scala tools, such as sbt, mill, and soon, Scala CLI.
9. Scalafmt: The Scala code formatter
Scalafmt keeps your codebase clean and consistent. By automating code formatting, it ensures that every team member follows the same style guidelines. It has a large number of configuration options so that it can fit your formatting tastes.
Why do we recommend Scalafmt?
Scalafmt has many advantages, but there are three in particular that make it a good developer experience tool.
- It’s integrated into most of the existing tools including Scala CLI.
- Easy configuration for team-wide consistency.
- It reduces code review friction.
Developer Experience tools that deserve an honorable mention
Our engineers have named three other Developer Experience tools that show promise or possess features that our engineers appreciate. Watch out for these tools, as they may become your new favorites in 2025.
WartRemover
WartRemover is a flexible linter for safer Scala code. You can use it to write your own rules that help you improve your company’s codebase. Also, it lets you choose some of the existing and well-tested rules. WartRemover helps prevent common coding errors, reducing the reliance on manual code reviews.
To use WartRemover, simply add it as an sbt plugin or as a compiler plugin with your tools. We recommend integrating it into your workflow for cleaner, safer code.
Mdoc: Documentation for the modern developer
Mdoc simplifies the creation and maintenance of technical documentation by evaluating embedded Scala code examples within markdown files. It integrates with other tools to create web pages for your projects.
It's a great developer experience tool if you want to ensure that your examples always work, enabling your users and junior developers to easily find correct examples.
Bloop: Fast build server for Scala
Bloop is a build server for Scala and Java programming languages. It provides other tools with the ability to efficiently compile code via Build Server Protocol, which enables it to integrate with both Metals and IntelliJ. Our engineers recommend Bloop’s for Scala projects as it delivers on its flagship features.
- It keeps the compiler optimized by reusing it between compilations.
- Integrates with most of the existing Scala tools.
- Allows multiple projects and modules to be compiled at the same time.
The other advantage of Bloop is that it can also be used from the command line, which will reuse any previously compiled artifacts for a project even if it was done previously by IDE.
It is the only developer experience tool on our list that is mostly used internally by other build tools. Previously mentioned sbt, Scala-CLI, and mill all take advantage of Bloop. The end-users might not even be aware that they are using Bloop, as typically it’s not something that they interact with directly.
Why do Developer Experience tools matter?
The right developer experience tools give your team a chance to be more productive, which in the long run saves money and resources.
Getting a developer environment up and running, making it efficient, and keeping it useful to your engineers is something most companies struggle with. With the right tools, your team will be able to spend time coding and solving actual problems instead of fruitlessly waiting or debugging their IDEs or build tools.
What matters to our engineers when picking developer experience tools
When working for our clients, we focus on improving the compilation time and making sure that their tools work properly. That is why, when selecting a Developer Experience (DX) tool, there are a few factors that our engineers always consider.
- Integration with existing tools: A new tool should fit well within the existing ecosystem of tools and workflows so that it can leverage and complement the features of our clients' current stack. This reduces the learning curve and potential disruption to the project.
- Usability: A good developer experience tool should be easy to learn and come with a user-friendly interface and design. Good usability is also about good documentation, accessible support, and a smooth overall user experience of the tool.
- Performance improvements: A good tool should provide faster execution times, better resource management, or more intelligent features like code completion and error detection. Tools that enhance performance can lead to quicker iteration cycles, allowing teams to develop, test, and deploy software more rapidly.
- Cost reduction: We are also paying attention if the tool reduces costs. There are different ways it can do it, for example, it can be through its pricing model or by allowing developers to work more efficiently.
9 Best developer experience tools for 2025: Closing thoughts
As we step into 2025, your selection of tools can profoundly impact your team’s productivity and satisfaction. From headless CMS platforms like Strapi to advanced Scala tooling such as Scalafix and Metals, investing in developer experience tools is no longer optional—it’s essential.
