User experience (often abbreviated as “UX”) plays a central role in digital product development. Successful products intuitively solve a specific problem for a particular group of people. Missing the mark with UX prohibits the long-term user engagement necessary for sustained business growth.
While this is certainly true, UX isn’t the only key to successful and sustainable digital products. Developer Experience plays an equally vital role in determining long-lived success.
Developer experience (DX) refers to the ease and intuitiveness of a product’s codebase and external services to the engineers that build and maintain it. We can break this down into codebase DX and the DX of integrations.
The key to good codebase-level DX is establishing and adhering to code standards. These should be codified and agreed upon by the development team. New developers can reference these standards as they start on new features or maintain the product. Here are some key features of standards that ensure good DX:
Detailed project documentation
Project documentation is often a developer’s first point of contact with a project. It is also the source of truth for the structure of the codebase and any external services used. Good documentation should answer the following questions:
- What programming languages, frameworks, and technologies are used?
- How does a developer new to the project stand up an isolated environment? What credentials are needed and where can they be found?
- What is the process for implementing new features?
- How do developers deploy code to the various testing, staging, and production environments?
- How/Where is the product hosted?
Intuitively named classes and variables
Use names that speak to the purpose of the class or variable. For example, if we want to model a user through a class, we should call it “User”. While this sounds simple, we’ve audited numerous codebases that do not follow intuitive naming. As a result, we spent more time understanding the code.
Test-Driven Development (TDD) is development process that helps ensure a durable codebase. With TDD, developers write tests for features before they implement them, and then use those tests to ensure that the feature works as intended. These tests make up test suite that lives along with the product, making sure new features don’t break old ones and that bugs fixes don’t return.
When building Roundtrip, we knew the complexity of the feature set and the security requirements of its data made clear code and detailed documentation critical to developer success. We documented every security feature we wrote that ensures PHI security since the product is HIPAA compliant. We also used intuitive names for classes and data models, such as “Patients”, “Trips”, and “Reports”. Finally, we outlined complex processes, such as the dispatching algorithm responsible for efficiently matching drivers with patients. These codebase level DX steps ensured an easy and quick onboarding process once Roundtrip hired its own internal development team. As a result, Roundtrip was able to stay focused on their growth.
The choice of external services that integrate with the product also greatly affects DX. When searching and deciding on these systems, look for the following features:
Detailed integration documentation
Good services understand that their success depends on the ability of developers to easily and effectively integrate their service into products. They provide detailed documentation outlining every API with request and response requirements and code examples.
Freely accessible documentation
One of the most annoying parts of selecting an external service is not having access to documentation before committing to the service. If a service doesn’t expose their documentation before signing a contract, developers cannot realistically gauge the level of effort of that integration. It can also make it hard to determine auxiliary requirements of the API, such as authentication processes, that can impact effort level.
Standards-based API design
Most commonly, a product integrates with an external service through an API. API design is a rich and complex field, but much of industry has solidified around the REST standard. Standards-based APIs provide predictability and consistency in accessing and mutating data. As a result, developers to spend less time understanding the structure of the API and more time build features that consume the API and bring value to its end-users.
SDKs in various programming languages
While a good service exposes its functionality through standards-based APIs, secure and reliable use of the API requires additional functionality. For example, most APIs authorize use through specific API keys or user tokens. In addition to APIs, DX friendly services provide code libraries (also known as software development kits or SDKs) that encapsulate auxiliary functionality into a convenient and well-maintained package. This reduces the code footprint of the product, and it bolsters the security and reliability of the integration.
Services that provide detailed and extensive support articles remove the redundancy of solving the same problem over and over. Great services also provide timely responses to support tickets. Finally, they are transparent about the health and status of their service through an easy to find a status page or twitter handle. If their service goes down and causes reduced functionality in the products that use them, developers spend less time isolating the issue.
Stripe is a service that exemplifies good DX. Their API documentation is exhaustive and provides code examples in several programming languages. It is also freely available, allowing developers to evaluate effort level before committing to using it. They have a great support page with easy to find articles and quick response to questions. Finally, they provide a status page and a Twitter handle that keeps developers updated on their service health.
Adhering to good DX through code standards and judicious selection of integrations gets better products into the hands of its users faster and more reliably. It also ensures smooth and efficient implementation of future features as development teams and stakeholders change.