Making Life Easier for Your Team
Some Thoughts on Making Developer Experience Easier for Everyone
Developer Experience (DX) is becoming increasingly important as companies strive to attract and retain top developer talent. In this issue, I'm sharing my own perspective on DX—the things I think are crucial based on my experience working with different teams. DX is all about giving developers a smooth, frustration-free environment so they can spend more time doing what they love—writing great code. We'll explore key aspects of DX, including fast feedback loops, efficient onboarding, and local development support. These are the areas where I've personally seen the most value.
From my experience, there are a few main areas to focus on to make DX a success. Do it right, and you'll see happier developers, faster delivery, and way fewer headaches.
Sure, there’s a cost involved, but for most companies, it's totally worth it. The productivity boost that comes once these tools are in place is huge. Plus, since these tools are foundational, you really only need to set them up once and then watch them continue to deliver value over time.
1. Fast Feedback Loops
First things first, fast feedback is crucial to improving any part of the development process. I remember working on a project for a bank where getting a new laptop took a month, and access to emails or GitHub permissions took another two weeks. That kind of delay is a productivity killer.
While that’s an extreme example, even common issues like slow PR review times or long pre-merge build checks (integration tests, deployment artifacts, etc.) can drag the team down. The goal is to reduce the time it takes to get feedback wherever possible.
For example, how does a developer know if their change has made it to staging? Do they need to manually check CI tools, or can you notify them via Slack, email, or whatever communication channel they use?
And it doesn’t stop there—how easy is it to diagnose problems when something goes wrong? If you notify a developer about two CI failures, are those messages clear enough for them to know what went wrong? Or do they have to dive deep to figure it out—was it a flaky environment, a type-checking failure, or a visual regression? If it’s a failed test, do you provide enough context for them to reproduce the issue locally, like giving them the exact command (yarn check:typecheck) to run?
Improving these feedback loops makes all the difference. Developers get unblocked faster, spend less time on repetitive tasks, and can focus on building features instead of troubleshooting roadblocks.
2. Onboarding Experience
A well-designed onboarding process is one of the most critical components of Developer Experience. Getting a developer up to speed quickly and efficiently sets the tone for their entire journey with the team.
I previously shared an article about how a health check script can help developers onboard into a new codebase and contribute quickly. Providing a README.md file is a good starting point (as most codebases do), but keeping it up to date is crucial as things evolve. A better solution is to provide a tool that checks all required tools and environments, reducing overhead for new team members.
Documentation: Accurate and up-to-date documentation is crucial. This should go beyond technical setup, encompassing team culture, communication channels, and best practices. A good approach is to have new joiners contribute to updating the documentation as they navigate it, helping ensure it remains relevant. Additionally, aim for an 'onboarding-as-code' approach by providing scripts that can automate and guide the onboarding steps, allowing for faster, more consistent onboarding.
Health Check Script: As part of the onboarding experience, a health check script runs before any work begins on a new codebase. This script verifies that all necessary software versions (such as Node, Python, Java, etc.) are correctly installed. It provides detailed guidance on what actions to take next, ensuring that developers are set up correctly from the start. Seeing everything checked and ready with green ticks gives new team members confidence and a sense of accomplishment.
3. Local Development Support
When dealing with a large codebase involving hundreds or even thousands of developers, it's crucial to stay organized and prevent people from stepping on each other's toes. Providing tools that support efficient local development is key. For instance, enabling hot-reload is helpful, but trying to compile and launch the entire frontend application at scale might not be feasible.
Before a developer pushes changes to CI, they typically run scripts to test their changes. Ideally, they should only need to run a subset of tests related to their changes. For example, if they are working on a product page, tests for the admin or checkout features may not be necessary in the local environment (though end-to-end tests should still run in CI).
Additionally, it's important to provide tools that help developers get relevant information while debugging—such as the current build number, feature toggle statuses, and environment identifiers (like instance URLs or specific database configurations). These small details can make a big difference in productivity.
Personally, I've run into issues where a strange bug was simply because a feature toggle wasn't enabled in my testing environment. These situations could be avoided if this information were visible while debugging. A browser extension that displays this state information would be handy.
Conclusion
This entire discussion is rooted in my experiences and what I've observed to be effective in enhancing Developer Experience. DX is about ensuring developers have what they need to do their best work without unnecessary friction. By focusing on fast feedback loops, effective onboarding, and robust local development support, you can create an environment that helps developers be productive and happy. Investing in DX isn't just about reducing frustrations—it's about giving your team the best chance to build amazing things. A little effort can have a lasting impact, turning a good team into a great one.