# How to Improve Developer Experience | LinearB Blog > Having a good developer experience can do wonders for your company’s success. Learn how to improve developer experience in this article. _This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._ ```json { "@context": "https://schema.org", "@type": "BreadcrumbList", "itemListElement": [ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://linearb.io/" }, { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://linearb.io/blog" }, { "@type": "ListItem", "position": 3, "name": "How to Improve Developer Experience", "item": "https://linearb.io/blog/improve-developer-experience" } ] } ``` [Home](https://linearb.io/) / [Blog](https://linearb.io/blog) / How to Improve Developer Experience # How to Improve Developer Experience ![Photo of Tris Pedro](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0) By [Tris Pedro](https://linearb.io/blog/improve-developer-experience#tris-pedro) | November 11, 2022 ![improve_developer_experience_713a38cafe](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/improve_developer_experience_713a38cafe?_a=BAVMn6ID0) Even with a great team, a project will struggle to take off if its developers are frequently stalled by unforeseen roadblocks. Whether due to dysfunctional tools or poor teamwork, the end result is the same: less efficient and effective work, resulting in lower productivity overall. Worst of all, these things contribute to a terrible developer experience (DX). Bad DX can also crescendo and affect the whole business, as you’ll struggle to retain your employees. So, in this article, we’ll show you how to improve developer experience to reach peak productivity. ## **Table of Contents** * [What Is Developer Experience?](#what) * [Baseline Your Developer Experience Metrics](#baseline) * [Identifying Blockers For Your Team](#identifying) * [Hiring Developer Experience Roles](#hiring) * [How to Improve Developer Experience Using Automation](#improve) ## **What Is Developer Experience?** [Developer experience](https://linearb.io/blog/developer-experience) defines how easy it is for a developer to implement a task—like changing the system or building something new end-to-end. It’s similar to user experience (UX), but for software developers. A positive developer experience will create more value by improving devs’ workflow, methods, and working conditions. Check out this great discussion between LinearB’s CEO, CTO, and R&D team leader. They discuss what DX is and how to measure it. And most importantly, they explain how to improve developer experience. ## **Baseline Your Developer Experience Metrics** The developer experience space is teeming with metrics. So it’s crucial to choose the ones that are most relevant to your company and will get the most buy-in from your software engineers. Here are a few crucial key performance indicators to consider: ### **Cycle Time** [Cycle time](https://linearb.io/cycle-time) is the duration it takes from an engineer’s initial commit to code deployment. Having a longer cycle time means that processes are inefficient. Long cycle times also lead to frustrated developers, negative customer feedback, and delayed deliveries. ![cycle time benchmarks](https://assets.linearb.io/uploads/cycle-time-benchmarks-1024x819.png) ### **Pull Request (PR) Size** A pull request’s size is a useful indicator of the complexity of the changes made to your code. If you [limit your pull request size](https://linearb.io/blog/pull-request-best-practices-our-tips), PRs are more likely to be reviewed quickly and thoroughly. In turn, this shortens the time it takes to get new features into your CI/CD pipeline. It also frees up developers to focus on more meaningful things—like coding. ### **Merge Frequency** Merge frequency is defined as the total number of pull requests or merge requests merged over a period of time. With efficient processes and short feedback loops, developers can merge more code and have more time for creativity and new initiatives. All these factors contribute to increased happiness and contentment in the developer journey. ### **Work In Progress** A team’s WIP reveals how many active pull requests are being handled by each member at any time. Developers risk becoming overloaded if they have too much work in progress. With LinearB’s Pulse, you can monitor your team’s WIP and daily activity to spot signs of burnout. ![team health](https://assets.linearb.io/uploads/Group-1308_2x-1024x490.png) ### **Weekend Activity** If many dev team members have to put in extra hours over the weekend, that’s a good indication that they’re overwhelmed. Most individuals are willing to put in overtime for major projects, but a constant increase in it could be a [sign of burnout](https://www.zdnet.com/article/developer-burnout-isnt-going-away-employers-need-to-act-now/). By minimizing weekend work, you can protect developers’ psychological safety. ![A man crying with the caption "When it's almost the weekend but you can't relax because you're working for the fifth weekend in a row"](https://assets.linearb.io/uploads/man-crying.png) Improve developer experience and never make your devs work a weekend again! Source: [Imgflip](https://imgflip.com/i/6zjk7h) ## **Identifying Blockers for Your Team** The developer journey is often convoluted and involves multiple steps. Successfully completing projects is difficult because teams must overcome numerous obstacles. But if developers are having trouble with regular tasks, it’s up to you to figure out a solution. Here are some potential blockers your teams might face: * Lack of internal support for developers like insufficient documentation or lots of steps that could be automated * Out-of-date tools and technologies that require application modernization * Ineffective communication about expectations and work coming up next * Poor task management due to high WIP, frequent context switches, or constant priority rearrangement * Poor time management due to a lack of focus, burnout, meetings, and interruptions But how can you identify these blockers in the first place? Some companies have resorted to sending out surveys or one-on-one chats with developers. But that’s not all you can do! Tracking metrics, like cycle time and PR size, can be a great indicator of bottlenecks. For example, extremely long PRs are a chore, so they negatively impact developer experience. And to make matters worse, teams aren’t deploying as many features as they’d like, and that’s taking a toll on their mental health. So, if you let metrics show you potential problems, you’ll know exactly where the problems reside—and you’ll know how to improve developer experience and as a result productivity. ## **Hiring Developer Experience Roles** Far too many organizations miss opportunities to have a good developer experience. Why? Because oftentimes, they don’t hire employees with developer experience in mind. Developer advocates can make a small impact on your teams’ overall development experience, but they aren’t a catch-all solution. ### **Developer Productivity Engineers** Hiring a Developer Productivity Engineer is an excellent solution to improving your DX, and it can help you nail your DORA metrics, too. These engineers take a look at your teams’ overall DX with an engineer’s lens, and they spot the fine details that you can work on. ### **Platform Engineering** Another fantastic way to keep DX in mind is hiring devs that work on [platform engineering](https://linearb.io/blog/platform-engineering). Your existing dev team is already working hard on hitting _their_ goals, so they don’t always have the time to make internal tools that make their lives easier. That’s where platform engineering comes into play. Basically, you have a team of devs that exist purely to make _all_ your devs’ lives easier. ### **Site Reliability Engineers** In a similar vein to platform engineering, Site Reliability Engineers (SREs) are exactly the kind of developers that would fit into those teams. As a blend of IT operations and software engineers, they can take away the hassle of dealing with deployment, maintenance, and other issues that can arise from software that’s already in production. This gives your other dev teams more breathing room to work on their stories for sprints and helps them spend less time playing catch-up with deployment issues. ![Meme of a satisfied seal saying "Devs when you finally learn how to improve developer experience"](https://assets.linearb.io/uploads/Meme-of-a-satisfied-seal-saying-Devs-when-you-finally-learn-how-to-improve-developer-experience.png) Happy happy devs! Source: Created using [Imgflip](https://imgflip.com/i/6zjlpg) ## **How to Improve Developer Experience Using Automation** [Automating developer workflows](https://linearb.io/blog/developer-experience-tools) can drastically cut the time it takes to integrate and deploy changes. Streamlining processes can also help developers create software that better serves business needs. Improve your code reviews’ efficiency with the help of LinearB’s WorkerB. This tool helps optimize your PR lifecycle and overall cycle time by offering PR context to code reviewers straight from Slack or MS Teams. This allows them to review PRs with fewer than five lines of changes from these platforms. And why stop there? LinearB’s gitStream helps automate PR routing. It automatically shows you which PRs can move along directly and which ones need the experts. This tool removes the hassle of PRs—so teams will have a great DX overall. [](https://github.com/apps/gitstream-cm/installations/new) ## **Final Thoughts** Great developer experience is critical for your company’s success. Developers with better processes and code support will be much happier—and accomplish much more. So let’s recap how to improve developer experience: 1. Use metrics to identify roadblocks to devs’ happiness 2. Hire dedicated staff to focus on improving developer experience 3. Automate and streamline processes with developer experience tools Want to learn more about how improving developer experience can impact your org’s performance? Check out our [Interact 2022 YouTube playlist](https://www.youtube.com/playlist?list=PL0cH8n2pFJ3u7jvJnWkpbdddNtkjAr0EW) and listen to first-hand stories about the importance of developer experience. ## Improve developer productivity with LinearB Find us on [](https://www.linkedin.com/company/linearb) [](https://devinterrupted.substack.com/) ## Your next read [![Cover image for Your software factory needs a context layer](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi) Eng. Metrics [Your software factory needs a context layer](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi) Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption... [![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc) Eng. Metrics [AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc) CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development... [![Cover image for AI ROI comes from measuring engineering outcomes on day one](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Blog_AI_ROI_comes_from_measuring_engineering_software_security_2400x1256_2c5eae0862?_a=BAVMn6ID0)](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes) Eng. Metrics [AI ROI comes from measuring engineering outcomes on day one](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes) Kraken Engineering Operations Lead Nik Sudan details how to establish day-one data infrastructure to accurately measure AI ROI. Discover why raw token adoption... ## Structured data _Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._ ```json { "@context": "https://schema.org", "@type": "Organization", "name": "LinearB", "url": "https://linearb.io/", "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg", "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.", "sameAs": [ "https://www.linkedin.com/company/linearb" ], "award": [ { "@type": "Award", "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms", "dateAwarded": "2026", "awardedBy": { "@type": "Organization", "name": "Gartner®" } }, { "@type": "Award", "name": "Great Place to Work Certification", "dateAwarded": "2025-2027", "awardedBy": { "@type": "Organization", "name": "Great Place to Work" } }, { "@type": "Award", "name": "America's Best Startup Employers 2025", "dateAwarded": "2025", "awardedBy": { "@type": "Organization", "name": "Forbes Magazine" } } ], "hasCertification": [ { "@type": "Certification", "name": "SOC 1 Type 2" }, { "@type": "Certification", "name": "SOC 2 Type 2" }, { "@type": "Certification", "name": "GDPR Compliance certification" }, { "@type": "Certification", "name": "ISO 27001" } ] } ``` ```json { "@context": "https://schema.org", "@type": "Article", "headline": "How to Improve Developer Experience", "url": "https://linearb.io/blog/improve-developer-experience", "author": { "@type": "Person", "name": "Tris Pedro" }, "datePublished": "2022-11-11T08:00:00.000Z", "dateModified": "2022-11-11T08:00:00.000Z", "image": "https://assets.linearb.io/image/upload/v1720000000/improve_developer_experience_713a38cafe.png", "publisher": { "@type": "Organization", "name": "LinearB", "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png" }, "description": "Having a good developer experience can do wonders for your company’s success. Learn how to improve developer experience in this article. \n" } ``` ## More on linearb.io ### Top navigation - [Book a Demo](https://linearb.io/book-a-demo) - [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews) - [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights) - [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact) - [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server) - [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation) - [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization) - [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting) - [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance) - [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support) - [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience) - [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience) - [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys) - [Platform overview](https://linearb.io/platform/overview) - [Register now](https://linearb.io/event/the-great-software-factory-debate-2) - [Customers](https://linearb.io/customers) - [Pricing](https://linearb.io/pricing) - [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb) - [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework) - [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq) - [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security) - [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy) - [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts) - [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources) - [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops) - [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report) - [Blog — Product updates and practical insights](https://linearb.io/blog) - [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io) - [API Docs](https://docs.linearb.io/api-overview) - [Status](https://www.linearbstatus.com/) - [Integrations](https://linearb.io/integrations) - [LinearB Library](https://linearb.io/library) - [Engineering metrics](https://linearb.io/library/engineering-metrics) - [Platform engineering](https://linearb.io/library/platform-engineering) - [Engineering glossary](https://linearb.io/library/engineering-glossary) - [Developer productivity](https://linearb.io/library/developer-productivity) - [AI in software development](https://linearb.io/library/ai-in-software-development) - [Engineering management](https://linearb.io/library/engineering-management) - [Developer experience](https://linearb.io/library/developer-experience) - [DevOps](https://linearb.io/library/devops) - [Engineering operations and the context layer](https://linearb.io/library/engineering-operations) - [Engineering efficiency](https://linearb.io/library/engineering-efficiency) - [Software delivery](https://linearb.io/library/software-delivery) - [Research and data](https://linearb.io/library/engineering-benchmarks-and-research) - [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026) - [Sign in](https://app.linearb.io/login) - [Enterprise](https://linearb.io/solutions/enterprise) - [Contact](https://linearb.io/contact-us) - [About us](https://linearb.io/about-us) - [Careers](https://linearb.io/careers) - [Service agreement](https://linearb.io/services-agreement) - [Privacy policy](https://linearb.io/privacy-policy) - [DPA](https://linearb.io/data-processing-agreement) - [Security FAQ](https://linearb.io/security-faq) - [Substack](https://devinterrupted.substack.com/) ### Footer _Additional links from the site footer, not repeated from the top navigation above._ - [GitHub](https://github.com/linear-b) - [LinkedIn](https://www.linkedin.com/company/linearb) - [Twitter](https://twitter.com/LinearB_Inc)