The High Cost of Ignoring Your Software Developers' Experience in the Workplace (and How To Fix It) Your company's success rests on your developers' skill and efficiency. Here's how to eliminate obstacles and free them to do their best work.

I've observed an odd trend in company board meetings. Marketing and sales vice presidents will come in with charts, reports and finely-tuned data. The CFO will fire up a dashboard detailing every penny of revenue and expense. The HR chief will share hiring metrics down to the last employee. But when it comes to engineering, the lifeblood of any modern company, there's little data — just a vague sense of what's working and what's not.

The reality is that engineering efficiency and developer experience remain a black box, even at some of the most tech-forward organizations. And inside that box lurk inefficiencies on an enormous scale.

I've heard of big banks that employ tens of thousands of developers who are operating at 30% efficiency because of bloated processes and unnecessary toil. This is more than a waste of resources. Frustrated developers quit. Company payroll sags under the weight of extra salaries needed to compensate for inefficiencies. Customers are stuck waiting on deliverables. Considering the global impact on productivity and output, this is easily a trillion-dollar problem.

The good news is there are simple, concrete ways to prioritize developer experience (DX) and engineering efficiency. I've seen the transformative benefits of improving DX as a developer, founder and CEO of three high-growth tech companies. Here's what every CEO should know:

Related: Use These 4 Tips to Attract and Retain Software Developers

The true cost of poor DX

Any company dependent on software development should be obsessed with optimizing developers' work experience. Research shows most software engineers spend more than half their workday performing tedious, repetitive tasks. No engineer wants to spend hours troubleshooting an issue that could be detected by automation or wait weeks for approvals from other teams. Yes, they can (and do) move on to other projects, but context switching increases drag and the likelihood of errors. It's also a stressful way to work.

A frustrating work environment leads to heavy turnover, which is costly at any time, but particularly now when demand for great developers far outstrips supply. In the U.S., there are around 162,900 open positions for software developers and related occupations, according to the Bureau of Labor Statistics. As word travels about a company's DX failures, recruiting becomes difficult, creating a downward spiral.

All of this translates to the bottom line, with developers earning a median salary of more than $120,000, leaving them idle amounts to burning money. Worse, inefficient engineering inevitably slows product development. Companies in competitive industries like banking, retail or healthcare that can't figure out DX will lose customers to competitors able to launch apps, updates and new products quickly.

The silver lining is that since most companies are new to DX, a few simple improvements can yield substantial benefits. Here are three practical ways to improve your developers' efficiency:

Related: The Future of Software Development in 2022 and Beyond

1. Make it someone's job

It could be a Developer Experience Officer (DXO), lead engineer or rotating team, but you need someone to own DX inside your company. Here at Harness, we have a Tiger Team that analyzes inefficiencies and recommends solutions. Here's a recent example: The team learned that our code base was too large for developers to test changes on their laptops, which turned a two-minute test into a 40-minute excursion to use a sufficiently robust computer. Once they identified the problem, the fix was straightforward: Reduce the number of microservices needed on developers' laptops so they could use their own computers to test the code.

2. Gather data, and put it to use

It's pretty ironic that engineering — of all departments — suffers from a lack of quantitative operational data. Most companies know more about sales team productivity than the engineering teams at the heart of their work. You can't fix what you haven't measured, so start by gathering hard numbers. Some useful metrics include the number of automated processes in your developer workflow, how much work a developer can complete within a certain timeframe and the lead time between a project's beginning and delivery.

Then, there are qualitative insights. Most companies rely on feedback from customer and employee experience surveys to make sure they are on target, but there's no equivalent for developers — and that's a huge oversight. Use surveys to gather qualitative data from engineers, and pinpoint bottlenecks and deficiencies to resolve. DX measurements can include metrics like how easy it is to locate the information, tools or systems they need to do their work.

3. Remove needless barriers

Barriers faced by developers can be cultural or technological. Endemic to many large companies is a culture of micromanagement and excessive oversight. For developers, that means wasting time waiting for someone to greenlight incremental progress. Instead, establish high-level guardrails around cost, security and quality, and give engineers free rein within those parameters. The streamlined process will boost creativity and productivity and increase developers' job satisfaction.

This goes hand in hand with upgrading developers' own tech toolkits. Too many are stuck using dated and manual tools and processes or hacking their own fixes. That's why I've worked to build solutions using automation and AI to enable users to build, test, deploy and verify on-demand. For example, if a developer is working on a feature, merging it into the main code can require thousands of tests, which could take hours to run. But using intelligent automation, the same process might take 20 minutes. There are even automations that allow you to programmatically define your guardrails and automate approvals when a project meets the specifications.

Related: How AI Will Transform Software Development

Ultimately, improving developer experience can't be a one-time event. It takes ongoing attention and iteration to gather relevant data, remove blockers and increase productivity and job satisfaction. Yet improvement is well within reach, and the potential return is far too great to ignore.

I dream that I'll soon walk into a boardroom and see a developer productivity dashboard as comprehensive as any other department's. We have the tools and data to unlock productivity, morale, efficiency, customer satisfaction and innovation gains. It's time to free developers from toil so they can do the work they love.