About a decade ago, I was a CIO evaluating a technology solution and I shared our primary requirements with a prospective vendor’s rep. He demoed at least three products from the company’s portfolio. Each tool had its own user experience, development approach, and learning requirements, but all three were needed to solve our business requirements. As CIO, I recognized that different parts of my team would either need to collaborate using these different tools, or I would have to hire more advanced developers capable of mastering them all. I decided not to invest in this technology solution because of the complexities of development involved.
The concept of developer experience (DX or DevEx) was not a primary or measurable objective back then. Few business leaders were thinking about the value of improving developer satisfaction, productivity, and happiness. But leading CTOs, digital trailblazers, delivery managers, and technical leads understood its importance. It’s why we bought large, multi-monitor workspaces, upgraded desktops to use the most powerful devices, brought in foosball tables to encourage work breaks, and celebrated major releases with our developer teams.
Varun Goswami, head of product management at Newgen Software, shares from Gartner survey results that 58% of software engineering leaders say developer experience is critical to the C-suite. “This signals a growing need for user-friendly and clutter-free interfaces, integrated ecosystems that offer a centralized hub for development, project management, documentation, repositories, and seamless collaboration,” he says.
Developers in organizations that prioritize DX are more likely to delight end users with innovations, release quality code on schedule, and strive for continuous improvements in the software development process. Some elements of a great developer experience are having access to the best tools, minimal interruptions, streamlined bureaucracy, and knowing that one’s work is appreciated. Here are 10 ways organizations are creating great developer experiences.
How to create great developer experiences
- Cultivate a diverse developer team
- Standardize tools to drive productivity
- Systematically address technical debt
- Seek developer input on architectural decisions
- Use tools and standards to enhance collaboration
- Clarify infrastructure and ops responsibilities
- Establish quality standards and metrics
- Bridge the app security and developer teams
- Foster a culture that avoids tech burnout
- Increase the developer team’s business acumen
Cultivate a diverse developer team
Great developer experience requires a company culture that rewards diversity, innovation, collaboration, continuous improvement, smart experimentation, and lifelong learning.
“Developer-focused companies tend to over-index employees who crave structure and organization,” says Keith Pitt, founder and CEO of Buildkite. “While these type-A workers are imperative, organizations must also foster a culture that values creative developers who push innovative ideas. In an increasingly automated industry, IT leaders need to cultivate an environment that encourages creativity and doesn’t punish calculated risks so visionaries can thrive.”
One way tech leaders can drive culture is to reward teammates whose behaviors and impact match with organizational goals.
Standardize tools to drive productivity
One school of thought says that devops teams should be free to use the tools they prefer. Another suggests organizations dedicate a small architecture team to creating standards and deciding which tools to use. A middle ground is to let developers create self-organizing standards for required tools and competencies while remaining open to new technologies that offer clear benefits.
“The developer experience gap widens as new tools, languages, and processes are introduced that can clash with developers’ established workflows,” says Laurent Doguin, director of developer relations and strategy at Couchbase. “The real win comes from tools that let them do their jobs easily, and this is especially true as developers experiment with genAI to automate tasks like boilerplate code generation, refactoring, or documentation writing.”
Building a great developer experience requires developing platforms and leveraging existing tools while leaders create opportunities to learn the technology and apply best practices. They also create a transparent process for selecting and experimenting with new technologies and communicate clear guidelines on the investment criteria.
“Developers are now more than ever looking for low-friction paths to success, and it’s not enough to just have advanced capabilities—the time-to-build and time-to-next-innovation has to be low,” states Cody De Arkland, senior director of product incubation at LaunchDarkly. “This means streamlining configurations, setting intelligent defaults, and having options to set advanced configurations.”
Expecting developers to customize everything about their digital workspace slows down everyone’s ability to deliver new technology and features.
Systematically address technical debt
It is stressful for developers to inherit poorly constructed code and then work under tight deadlines to make functionality improvements. Businesses keep the cycle going by over-focusing on feature development without asking the dev team what areas of the application require upgrading.
“In the race to move fast and stay competitive, companies are accumulating technical debt like never before,” says Bob Quillin, chief ecosystem officer at vFunction. “Technical debt, especially architectural tech debt, reduces team morale and makes it harder to add new features and take advantage of new tech like genAI, draining resources and hampering developer retention and productivity.”
To improve the developer experience, create clear objectives for agile development teams to reduce technical debt on an ongoing basis, create a clear process for cataloging technical debt issues, and establish clear guidelines for how teams should prioritize technical debt remediation. Departments should consider several forms of technical debt, including data debt, operations debt, security debt, and architectural debt.
“Understanding an application’s current architecture enables developers to prioritize nagging app problems and resolve issues before they become outages,” Quillin adds. “Architectural observability enables a cultural shift that empowers developers to align technical debt remediation with project goals and makes it easier to fix the technical debt baggage that’s been weighing down release cycles and impacting resiliency.”
Seek developer input on architectural decisions
In my book, Digital Trailblazer, I recommend agile retrospective meetings, inclusive solution brainstorming sessions, and blameless postmortems as essential practices for great developer experiences (also see my introduction to agile methodology on InfoWorld). When defining architecture and selecting development frameworks, I believe hosting collegial debates, making decisions, capturing feedback, and continuously evolving standards are all supportive practices for developers to be involved in.
“Today, engineers are expected to be superhumans who have mastered a myriad of technologies, infrastructure, networking, and more, often leading to cognitive overload,” says Sandhya Sridharan, head of engineers’ platform and experience at JPMorgan Chase. “To effectively streamline software development, establishing a strong foundational platform that is opinionated as well as one that facilitates a self-service model is critical.”
Finding the right balance between capturing developers’ input, fostering experimentation, and driving standards isn’t easy, especially in large enterprises with many platforms and application types. Dictating standards degrades developer experience, so it’s important to share how and why architectural decisions are made.
Sridharan recommends, “While this may seem obvious, it requires leaders to answer questions around engineers’ challenges as well as overarching business priorities, ensure the platform is not only reliable, scalable, and secure but also able to abstract complexities away by providing a set of patterns and opinionation, keeping the developer in the ‘flow’ at all times.”
Companies seeking optimal developer experience must also consider the disparity in skill set and ease of onboarding new developers. It’s not surprising to see differing opinions of how architects and developers should partner on questions such as where standards are needed, where flexibilities are advantageous, and what documentation to create.
“While building a dev tools product, maintaining a balance between having an ‘opinionated’ product and an ‘open’ product is vital,” says Gilad Shriki, co-founder of Descope. “Being too opinionated can restrict the user base, while excessive openness may intimidate early-stage developers. To strike this balance, ensure a unique product approach with clear benefits and ‘end state,’ along with ample collateral, sample code repos, tutorials, and community support.”
Use tools and standards to enhance collaboration
Developers tend to loathe frequent or unproductive meetings and prefer using collaboration tools to share project updates. Organizations that lack a unified approach to collaboration, communication, and documentation across teams can dampen developer experience and productivity, says Joseph Varghese, co-founder & CTO of StreamAlive.
“In onboarding developers and tech talent, many companies lack engaging tools and resources necessary to create a transparent and inviting culture that encourages communication and collaboration—impeding the developer experience. As tech teams and developer talent are often the backbone of organizations, it is essential that they can effectively discuss issues and potential solutions with other team members across organizations.”
Delivery leads should focus on setting standards in areas such as:
- Templates for user story writing that include acceptance criteria and embedded diagrams
- Standards for documenting weekly updates rather than scheduling status update meetings
- Documentation requirements for what must be updated with every production release
- Best practices for using virtual meeting and asynchronous communication technologies as effective communication tools
A great developer experience puts the focus on collaboration by standardizing tools that connect to the development workflow and setting clear communication expectations.
Clarify infrastructure and ops responsibilities
Nearly 10 years ago, I asked who owns devops and suggested that IT operations seize the day. The idea was to learn cloud infrastructure and devops automation tools to cement a productive, collaborative, innovative, and reliable devops operating model.
Today, there are many new tools to manage, automate, and secure cloud infrastructures and that’s driven a shift in both developer and operations responsibilities.
“In today’s cloud infrastructure landscape, developers undergo a transformative shift and transcend mere coding to embracing full-service ownership,” says Dattaraj Rao, chief data scientist at Persistent Systems. “Developers now code, ship, and run applications while infrastructure is coded and provisioned dynamically. This evolution towards comprehensive ownership is empowered by accessible cloud-based AI services, enabling sophisticated solutions.”
When looking to improve developer experience, it’s important to identify who’s responsible for infrastructure and other operations responsibilities. There isn’t a one-size-fits-all approach: regulations, types of applications, scale of usage, data complexities, and security considerations are just some of the factors that may determine organization and team responsibilities.
Establish quality standards and metrics
Are copilots and code generators always accurate, high quality, and useful? In my article, what’s hype and where to drive results with AI copilots, I quote research showing users accept 30% of code suggested by copilots, implying that code suggestions require review and validation before being used in applications.
Jonathan Vila, developer advocate at Sonar, asks, “The market is full of tools that help the production of code, including IDEs, plugins, and online services. AI is becoming a commodity for all of them, but at what cost?”
When reviewing tools, especially generative AI ones aiming to improve productivity, a smart approach to improve developer experience requires defining quality standards and using automated tools to validate results.
Vila adds, “It is necessary to check the code generated by AI before adding it to our repositories. Linters and quality gates are the perfect gatekeepers to take the best value out of AI without compromising the codebase.”
Teams that focus on the quality and productivity of their own developer experience are more likely to do the same when designing and developing applications. Defining quality standards and metrics ensures developers have clear expectations and acceptance criteria to work from.
