Over the last few years, it has become increasingly (and painfully) clear that cognitive overload on developers is one of the root evils creating a poor developer experience. The explosion of cloud native tooling and infrastructure, combined with the shift left and “you build it, you run it” trend, can be overwhelming to engineers and decrease both their productivity and overall quality of experience.

Platform engineering to the rescue

To navigate these complexities, many engineering orgs have started implementing automation, unification, and guardrails over their cloud-native environments. These internal “Dev Tools” are then provided to the engineering teams in the shape of a product, or platform. These trends have been inspired by industry leaders like Google, Airbnb, and Spotify and they come under the banner of "platform engineering".

This is why, more and more, we see platform engineering teams taking on the role of enhancing the developer experience for various product teams. These teams create essential tools to create a streamlined, self-service internal development platform. By treating this platform as a product, they aim to consistently refine the developer experience, using ongoing feedback from developers to guide improvements. 

Gartner's 2023 Agile and DevOps HypeCycle offers insights that resonate with this shift:

• "Platform engineering has climbed rapidly to the Hype Cycle's peak. Emerging innovations, like internal developer portals, are making notable entries.”
• "Few organizations showcase a high level of Agile and DevOps maturity. The mandate for software engineering leaders is dual-fold: nurture advanced teams while also guiding or restarting others on their journey."

Furthermore, Gartner TalentNeuron data highlights a surge in demand for skills enhancing developer experience via platform engineering. From mid-2020 through mid-2022, job postings citing such skills have spiked.

An internal developer platform is the primary product of a platform team. 

As defined by the internal developer platform org, “an Internal Developer Platform is built by a platform team to build golden paths and enable developer self-service. It consists of many different techs and tools, glued together in a way that lowers cognitive load on developers without abstracting away context and underlying technologies”

The true value of a platform lies not only in its implementation but also in its adoption rate among engineering teams and the tangible impact it has on their workflow and product development.

Internal developer portals act as the gateway for developers to discover and leverage the capabilities of the internal developer platform. It is through these portals that developers can easily access and explore the vast array of tools and resources, making the internal developer portal the backbone of platform engineering.

Internal Developer Portals: The solution to complexity

How can software engineering leaders minimize friction and maximize flow in the design, development, and delivery of software? The answer lies in internal developer portals. These portals offer a versatile framework that abstracts away complexity in various workflows, such as design, development, deployment, and post-deployment operations.

As explained by Paul Delory, a Research VP with Gartner, “IDPs provide a curated set of tools, capabilities and processes. They are selected by subject matter experts and packaged for easy consumption by development teams. The goal is a frictionless, self-service developer experience that offers the right capabilities to enable developers and others to produce valuable software with as little overhead as possible. The platform should increase developer productivity, along with reducing the cognitive load. The platform should include everything development teams need and present it in whatever manner fits best with the team’s preferred workflow.”

Developer portals play a crucial role in enhancing the developer experience. They create a centralized "app store" that promotes software reuse, enhances onboarding, streamlines delivery, and facilitates knowledge sharing. By integrating with documentation, source code, and artifact repositories, organizations can adopt and scale innersource practices. Moreover, the portals integrate with automation, monitoring, and incident management tools, enabling continuous operations.

It's important to note that developer portals go beyond providing a superficial overview. As eloquently described in this article from the Platform Engineering Org, "putting a pile of bullsh*t on a pane of glass won't solve any problems." To begin with, it is essential to curate and present only the relevant information for the specific use case. Furthermore, taking action is of utmost importance. Therefore, the steps for improvement should not only be easily accessible and comprehensible but also ideally automated, enabling standardization and enhancing the workflow for developers.

Internal developer portals should empower developers to perform activities throughout all phases of the software delivery life cycle (SDLC).

• Day 0: Discover and Create - Provide ready-to-use templates, documentation, and integration with developer tooling for creating new software applications, services, and components. This includes a software catalog for tracking assets and dependencies.
• Day 1: Integrate and Deploy - Offer a single dashboard to manage distributed infrastructure across cloud and on-premises environments. Support multiple DevOps automation tools and facilitate API management for creating, managing, and exploring API definitions and policies.
• Day 2: Operate and Improve - Provide access to service dependency graphs, operational metrics, logs, and traces. Offer an application-centric view into Kubernetes clusters for containerized deployments. Enable understanding of interdependencies, performance, ownership, on-call responsibilities, and incident response.

By unifying a diverse set of platform services and tools into one cohesive portal, internal developer portals enhance developer experience and simplify development workflows.

If you're interested in learning more about internal developer portals in the age of Platform Engineering, check out our recent article, "Ultimate Guide to Internal Developer Portals." It delves into the emergence of platform engineering and reliability trends to address the needs of modern engineering organizations.

In a nutshell, building an internal developer platform and adopting an internal developer portal are quick wins for improving the developer experience. Additionally, reliability engineering plays a vital role in ensuring standardization, providing developer autonomy, and enabling focus time by minimizing disruptions caused by incidents.

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
• Runbooks
• 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.

These frameworks offer leaders valuable insights on enhancing developer productivity through the measurement and prioritization of key aspects of DevEx. By considering the dimensions of feedback loops, cognitive load, and flow state, organizations can effectively understand and improve developer experience.

To start, it is recommended that organizations identify common symptoms of poor developer experience, allowing for quick and easy improvements before investing in formal DevEx initiatives. Once the low-hanging fruits are addressed, organizations can then focus on measuring DevEx across the different dimensions to identify trends, make informed investment decisions, and navigate changes successfully.

For smaller organizations and startups, DevEx plays a crucial role in achieving rapid innovation and market fit. As organizations grow, prioritizing developer experience becomes instrumental in driving business performance through improved engineering efficiency, enhanced product quality, and increased employee retention.

While measuring developer productivity holistically remains a challenge, prioritizing and measuring developer experience provides a proven pathway to building high-performing organizations. Understanding the significance of DevEx, leaders can create an environment that fosters developer productivity and propels their organizations towards success.