The Developer Experience for Platform Engineers

Aligning software and platform engineering for enhanced DevEx

Why Am I Writing This Document?

Throughout my journey as a member of engineering teams, I held the belief that software engineers (SE) and platform engineers (PE) could function relatively autonomously within the same project. However, this perspective shifted dramatically upon assuming a PE leadership role on projects. It became increasingly evident that I could no longer solely concentrate on platform development; rather, I needed to intimately grasp the specific needs of SE engineers beyond merely providing a platform. This realisation underscored the importance of integrating the efforts of both teams seamlessly. Central to this integration was understanding the concept of developer experience (DevEx).

This document reflects my experiences within my current project, crafted to capture insights and lessons learned. As my expertise evolves, so too will the depth and breadth of this document, serving as a living repository of knowledge and best practices in enhancing the developer experience for platform engineers.

What Is the Developer Experience?

The developer experience encompasses the overall experience and satisfaction of developers within an engineering team. It examines how various factors, systems, technology, processes, and culture affect the effectiveness of development.

Components of the Developer Experience

Documentation: Clear, comprehensive, and up-to-date documentation is essential for developers to understand how to use a particular technology effectively. This includes API references, tutorials, guides, and examples.

Ease of use: Developers prefer intuitive tools.

Performance and reliability: Developers expect tools to be performant and reliable. This includes fast build times, minimal downtime, and consistent behaviour across different environments.

Flexibility and customisation: Developers often have diverse needs and preferences, so tools that offer flexibility and customisation options tend to provide a better developer experience.

Feedback and iteration: Developers appreciate responsive maintainers who actively solicit feedback, address bugs and issues promptly, and regularly release updates and improvement.

Fluid communication: Whether it’s within teams, across departments, or with external stakeholders, fluid communication fosters collaboration and innovation.

Developer onboarding: Smooth onboarding sets the tone for a positive developer experience from the outset. It involves familiarising new developers with the tools, process, and culture. Comprehensive documentation accelerates the onboarding process.

How to Improve the Developer Experience

Improving the developer experience is important for technology providers because it can lead to increased adoption, higher levels of developer satisfaction, and ultimately greater success for the technology platform and project.

Developer Experience Strategy for Platform Engineers

Platform engineers (PEs) essentially act as the unsung heroes of a smooth development process. Their mission is to empower developers by building and maintaining the platform that underpins development. Well-engineered platforms reduce friction by hiding complexity that is nonessential to the value of the developer. To minimise friction, software development teams need a strongly engineered platform that offers self-service functionality so developers can simply focus on building customer-facing features.

User-Centric Design and Accessibility

• Foster broad developer empathy. A deep understanding of the needs, preferences, and challenges faced by developers is a necessity.
• Design a platform with a primary focus on end users. Prioritise services, resources, and features based on the requirements of the developers. Empower developers to perform common tasks without unnecessary dependencies on platform engineers.
• Provide comprehensive and well-organised documentation. Include clear examples, tutorials, and use cases to help developers understand the platform.
• Design the platform to abstract away infrastructure complexities. Developers shouldn’t need to be platform ‘experts’, but involve developers in the decision-making process, understanding their pain points and preferences.

Consistency, Collaboration, and Continuous Improvement

• Maintain consistency in tooling and processes across different parts of the platform, if possible, dependent on project/client requirements and preferences.
• Build feedback mechanisms. Establishing feedback loops to collect ongoing input ensures a consistent developer experience.
• Implement effective channels for questions and support.
• Implement robust monitoring and analytics to track usage patterns, identify pain points, and measure the effectiveness of the platform.
• Proactively iterate on the platform based on feedback to ensure it stays aligned with developer needs.

Flexibility, Automation, and Governance

• Allow for some flexibility and customisation in the development environment to accommodate different preferences and workflows.
• Leverage infrastructure as code (IaC) tools to automate deployments.
• Implement a robust CI/CD pipeline to streamline the development and deployment process.
• Automate developers’ repetitive tasks to save time and reduce manual efforts.
• Implement robust automated governance mechanisms to ensure adherence to security and compliance standards.
• Facilitate knowledge sharing, discussions, and collaboration.

FAQs

1. Why are we suggesting that the developer role is more crucial than the role of a platform engineer?

Rather than comparing the importance of one role over the other, it’s more accurate to say that they are both essential components of a successful software development process. The importance of each role may vary depending on the specific needs and priorities of a given project and/or client.

2. Is platform engineering merely a means to achieve a better developer experience?

Many aspects of platform engineering contribute to the developer experience. While platform engineering enhances the developer experience, its scope extends beyond the needs of developers.

a) Infrastructure and reliability:

Platform engineers ensure that the underlying infrastructure is robust, reliable, and scalable. While this indirectly impacts developers, it’s essential for overall system stability and uptime, for all end users.

b) Security and compliance:

Platform engineers focus on security measures, such as access controls, encryption, and vulnerability management. While developers benefit from a secure environment, these efforts extend beyond their immediate experience. The organisation benefits from adherence to legal and industry standards.

c) Automation and efficiency:

Platform engineers automate deployment pipelines, reducing manual work for developers. This streamlines the development process but also benefits system administrators and operations teams, particularly reducing manual work, and faster incident response.

d) Monitoring and observability:

Platform engineers set up monitoring tools to track system health. While developers benefit from identifying issues early, these tools also aid platform maintenance, helping to identify any potential issues.

3. Is the developer experience the same for every developer?

No, it can vary. Factors such as individual preferences, expertise, experience, and the specific tools and technologies used play a crucial role.

a) Background and skill level:

Novice developers might find certain tasks challenging, while experienced developers may navigate them effortlessly. Developers with diverse backgrounds (front end, back end, mobile, etc.) encounter different challenges.

b) Programming languages and frameworks:

Developers working with different languages (Python, JavaScript, Java, etc.) have distinct experiences.

c) Personal preferences and workflows:

Some developers thrive in a quiet environment, while others enjoy pair programming.

4. How can I measure the developer experience?

The developer experience can be subjective, but there are a few ways to help measure its effectiveness.

a) Feedback: Gauge satisfaction levels.

b) Issue tracking: Monitor bugs and feature requests to identify recurring issues and trends.

c) Time to development: Measure the time from code commit to deployment.

d) Velocity: High velocity would suggest efficient workflows and effective collaboration.

5. What roles can generative AI (GenAI) play in the developer experience, if any?

While responsible AI practices are essential, GenAI could complement a developer but should not be solely relied upon, given that GenAI platforms are in constant learning modes and therefore may not have all the correct answers. However, integrating GenAI with development tools can be seamless and can improve efficiency of code. One example is GitHub Copilot, which will assist developers by providing autocompletion suggestions as they write code.

Standard Tooling

Integrated development environments (IDEs): Popular examples include Visual Studio Code, IntelliJ IDEA, Eclipse, and JetBrains’ suite of IDEs (e.g., PyCharm, WebStorm).

Version control systems (VCS): VCS tools are essential for managing code changes, collaboration, and versioning. Git is the most widely used VCS, with platforms like GitHub, GitLab, and Bitbucket providing hosting services and additional collaboration features.

Package managers: Package managers streamline the process of installing, updating, and managing dependencies for software projects. Examples include npm (for Node.js), pip (for Python), Maven (for Java), and Composer (for PHP).

Build tools: Build tools automate the process of compiling, packaging, and building software artifacts. Common build tools include Apache Maven, Apache Ant, Gradle, and GNU Make.

Testing frameworks: Testing frameworks facilitate automated testing of software applications, ensuring code quality and reliability. Popular testing frameworks include JUnit (for Java), pytest (for Python), Jasmine (for JavaScript), NUnit (for .NET), and RSpec (for Ruby).

Continuous integration/continuous deployment (CI/CD) tools: CI/CD tools automate the process of integrating code changes, running tests, and deploying applications. Examples include Jenkins, Travis CI, CircleCI, and GitLab CI/CD, GitHub Actions.

Containerisation and orchestration tools: Containerisation tools like Docker and container orchestration platforms like Kubernetes have become standard for deploying and managing scalable, portable applications in distributed environments.

Monitoring and logging tools: Monitoring and logging tools help developers track application performance, diagnose issues, and troubleshoot errors. Examples include Prometheus, Grafana, ELK Stack (Elasticsearch, Logstash, Kibana), and New Relic.

Collaboration and communication tools: Developers rely on collaboration and communication tools to coordinate with team members, share knowledge, and manage project workflows. Examples include Slack, Microsoft Teams, Zoom, and Atlassian’s suite of tools (e.g., Jira, Confluence, Bitbucket).

Postman: API development tool to simplify the process of building, testing, and documenting APIs.

Swagger: A toolkit that helps developers design, document, and use REST APIs. It includes tools for writing specifications, creating interactive documentation, and generating code.

LocalStack: An open-source tool that emulates various AWS services on a developer’s local machine, enabling offline development and testing of AWS-based applications.

Conclusion

The developer experience for platform engineers is a critical component that can significantly influence the success and sustainability of a project. By prioritising user-friendly workflows, comprehensive documentation, robust tooling, and a supportive community, platform engineers can create an environment where developers thrive.

Remember, a bad developer experience can poison a project.

Glossary of Developer Terms

Algorithm: A step-by-step procedure or formula to solve a problem or accomplish some end.

API (application programming interface): A set of rules and protocols for building and interacting with software applications.

Back end: The server side of a software system or application where data processing and storage occur. Effectively, machine-to-machine.

Front end: The client side of a software system or application, responsible for user interface and interaction. Effectively, human-to-machine.

Function: A self-contained block of code that performs a specific task or operation.

Framework: A reusable set of libraries or modules that provide a foundation for building software applications.

Library: A collection of pre-written code modules that can be reused and shared across different projects.

Syntax: The set of rules that define the combinations of symbols that are considered to be correctly structured programs in a programming language.

Runtime: The period during which a program is executing, from start to termination.

Full-stack: Referring to developers who are proficient in both front-end and back-end development

RESTful: REpresentational State Transfer, an architectural style for designing networked applications, typically using HTTP as the communication protocol.

Payload: The data transmitted over a network, often associated with HTTP requests and responses.

HTTP methods: GET, POST, PUT, DELETE, etc., used to indicate the desired action to be performed on a resource.

Unit test: A type of software testing where individual components (or units) of a program are tested in isolation to ensure that they behave as expected.

Integration test: A type of software testing where individual units or modules are combined and tested as a group to verify that they work together as intended.

End-to-end test (E2E test): A type of software testing that tests the entire application from start to finish to simulate real user scenarios.

Regression test: A type of software testing that verifies that a recent program or code change has not adversely affected existing features.

Performance test: A type of software testing that determines how a system performs under various conditions, such as load, stress, and concurrency.

Load test: A type of performance testing that evaluates a system’s behaviour under normal and peak load conditions.

Stress test: A type of performance testing that evaluates a system’s behaviour under extreme conditions beyond normal usage patterns.

Usability test: A type of software testing that evaluates how easy a system is to use by testing it with real users.

Smoke test: A type of software testing that verifies whether the most critical functionalities of a system are working properly after a build or deployment.

Health check: A process that evaluates the overall health and status of a system, service, application.