Developer experience, as mentioned earlier in this article, requires more than simply the adoption of tools.
It requires changes in the culture of the organization, their processes and behaviors as well. Below are some of the ones we have found to be somewhat universally applicable to most companies:
Remove cognitive load
One obvious way to improve developer experience is by reducing cognitive load. This can be achieved by unifying relevant information from different tools in the engineering stack into a single place. Developers shouldn't have to search through multiple tools that contain irrelevant information for common use cases. It's important to remember that visualizing issues without addressing their root causes doesn't provide a real solution. Instead, it's crucial to tackle the underlying challenges directly in order to make genuine progress. Our recommendation is to create a unification layer that seamlessly integrates with the necessary tools, allowing for easy navigation from high-level to low-level details when needed.
Efficient (async) collaboration
When it comes to establishing a strong culture of collaboration between different engineers (and teams), transparency is key. When it comes to tool integration, consider adopting a centralized platform that connects your core tools, such as Slack, Jira, or GitHub and connects them to your organizational context. With this approach you can easily find out who to reach out to and where when incidents happen, or when using a specific component or API from a different team. Where companies can create team homepages with all the relevant information about each team and create a "Team API" with all of the information about how to work with this team. A few examples of the information that would live here would be:
- The code (e.g. libraries, runtime endpoints, UI, libraries, repos owned by this team)
- Versioning: how the team communicates changes to its code and services
- Wiki, docs and how-to guides
- Practices and principles w/ the team's preferred way of working
- Communication (tools and channels used for communication)
- Work info: what the team is working on, what's coming next and their overall priorities
- Collaboration mode: how other teams should interact with these teams and contribute to the services they own
This can also help leaders identify teams with cognitive overloads in their areas of responsibility (services, domain complexity, software boundaries, etc).There are a few principles we should use when it comes to structuring teams to reflect Conway's Law (that states that the systems that are going to be built are a reflection of the team and communication structure of the people building it).
In the Team Topologies book, their research shows that you should try to reduce as much as possible the communication streams to only the people that need to be involved (too much communication is bad communication). Each team should communicate mostly within itself and a few touch points like the company all hands to make sure everyone is aligned should be enough.
Provide clear (incremental) milestones in a single place
Providing clear guidance on the next actions for engineers is crucial. It ensures they have a precise understanding of the subsequent steps required, whether it involves open pull requests, active incidents, or upcoming tasks for ongoing initiatives with their respective due dates. This approach not only alleviates cognitive burden for developers by consolidating all relevant information in one place, but also creates an engaging experience akin to Role-Playing Games (RPGs). Similar to role-playing games (RPGs), the clearly defined incremental steps cultivate a profound sense of accomplishment, delivering a dopamine hit and making the completion of tasks even more rewarding.
Promoting Self-service DevOps Workflows
Enabling developers to autonomously access tools and resources not only boosts their productivity but also ensures consistency across processes. This decentralized approach to software delivery allows teams to operate at the speed of business, striking a balance between autonomy and standardization.
Self-service plays a crucial role in improving the developer experience by eliminating process inefficiencies and unnecessary steps. For instance, the ability to create a development database or set up a test environment without raising a ticket can enhance developer productivity and maintain their state of flow.
Moreover, developer self-service brings consistency and repeatability to otherwise disjointed processes and manual handoffs, reducing errors. The goal is to make the right thing to do the intuitive thing to do. By offering access to pre-vetted open-source libraries from a trusted component catalog, self-service improves governance and enhances the developer experience.
Optimizing the Development Environment
To quickly identify areas of improvement in your development process throughout the Software Delivery Life Cycle (SDLC), it is crucial to recognize bottlenecks and inefficiencies. Here are some examples of how you can assess and address issues in your development environment:
- If your Lead Time to Change (LTC) is within a week and you deploy at least once a week, but your Change Failure Rate is high, it may indicate that teams are rushing changes before they are ready or lacking support for the changes being deployed.
- If you’re deploying once a month, on the other hand, and your MTTR and CFR are high, then your team may be spending more time correcting code than improving your product. To tackle this, we recommend implementing automated quality guardrails like release quality gates that utilize Service Level Objectives (SLOs) as the primary reliability and quality indicator that gates the release. This approach empowers developers to move quickly while ensuring high reliability.
- If developers have limited focus time, consider initiatives such as designated no-meeting days, consolidating meetings, and promoting asynchronous work.
- If the productivity is not up the expected standards, consider automating repetitive tasks, improving development tools, and refining coding standards.
By optimizing your development environment, you can streamline processes, increase efficiency, and foster a more productive and reliable software delivery.
Improve documentation and processes
Let’s face it, it’s extremely rare to find companies that have all their documentation and resources up-to-date, well organized, easily accessible and with high quality.
However, it's crucial for organizations to invest in creating documentation, tutorials, runbooks, and guides that are user-friendly and readily available for specific use cases.
For example, having runbooks, API specifications, and dependency maps in a centralized location, alongside the incident triggering page, can greatly reduce cognitive load and mean time to recover during stressful incidents.
Creating and maintaining documentation is crucial, ensuring it is both comprehensive and easily accessible. By integrating the documentation process into workflows (e.g., making it part of definitions of done), it becomes a seamless part of development. Emerging AI tools automate content production, simplifying the documentation process by extracting relevant information from code and automating code comments.
To further enhance usability, consider utilizing internal developer portals (IDPs). These portals help unify all documentation from different tools alongside corresponding services, providing easy access whenever needed. The combination of streamlined processes, productivity-boosting AI tools, and IDPs ensures documentation is not only created and maintained effectively but also readily usable for all.
As you can see, by implementing tools such as internal developer portals, you can significantly enhance the attainment of these improvements. To delve deeper into the world of internal developer portals and kickstart your journey, I invite you to consult the comprehensive guide we wrote. It contains all the essential information you need to know about this topic.
However, it's important to emphasize that many of these improvements necessitate more than just adopting tools. They require cultural and process changes within your organization, as exemplified earlier in the article.
The key is to identify areas where you can make low-effort, high-impact improvements and address them promptly. Measure the impact and severity across different dimensions of DevEx for various teams, and prioritize accordingly.