Tool fragmentation, poor documentation and team-based silos can hamstring the developer experience, members of Protocol's Braintrust say.
Good afternoon! In today's Braintrust, we asked the experts to think about developer experience and let us know what they thought was the toughest part of creating an environment that works for everyone. Questions or comments? Send us a note at firstname.lastname@example.org
General partner at Vertex Ventures
There are more than 27 million software developers today. They're highly sought-after, and they’ll tell you their day-to-day is inefficient because of the dozens of fragmented tools and services used to build scalable web applications. It’s lost productivity and a broken customer experience.
Why? Developers are often left prioritizing short-term gains versus long-term customer experiences. They're so focused and project-driven that they’re focused on developing features that users can see immediately.
As with building a company, it's easier to get stuck in the day-to-day. I advise our portfolio, many of whom are focused on improving the developer experience, to ask themselves three questions: What is the vision? What are you building? What is the application experience you’re looking to build?
Those are naturally opposing focuses, and there are things you can do in the life cycle to improve for each team. Optimize for the end game. Don’t have developers spin up individual instances. Deploy service catalogs that manage microservices. Build for the bigger picture and make their technology and stack easy to maintain, reliable and secure.
At the end of the day, instead of bringing on more tools that help individuals, focus on creating a better and more focused experience for all of your teams.
Head of Developer Relations at Cockroach Labs
There are several parts to addressing the challenges of building a great developer experience. First, companies often don’t think through the “first contact” moments. Consequently, the things they believe are “nice-to-haves” — like demos, sample code and solid, easy-to-navigate documentation — are actually crucial. Developers need a complete experience when encountering a project for the first time. Developers discover new projects and tools every day, and don’t have the time to wade through bad documentation and/or, “Here’s some code, have fun.” If developers can’t quickly understand the value for them, they’ll move on. It’s often a one-shot opportunity: They either get it or they leave.
Beyond “first contact,” it’s essential to think about the UI carefully. Some environments have overbuilt UIs that make it hard for developers to find what they need to do their jobs or build cool applications, and for others, the UI is practically nonexistent. As I mentioned, a “just read the docs” approach will not cut it. Nor is bombarding developers with everything upfront, instead of only what’s necessary to get started (sample code, sample apps, short video tutorials), be successful (fun, intuitive UI) and, after, show the path to where to learn more (longer tutorials, docs). Finding that balance is tricky, and it's a moving target.
The bottom line is, if you don’t make it easy and quick to adopt new or existing solutions and tools, your odds of getting engagement will hover near zero.
Senior Vice President of Engineering at Netlify
The most significant challenge companies are facing in creating a great developer experience is the speed of innovation within the developer toolchain. A unified developer experience is critical to allow teams to focus on feature innovation and shipping code with quality, reliability and scale. When the toolchain isn’t kept simple, it can have the reverse effect due to unknown inner dependencies and lack of documentation. Without a clear understanding of what their team needs, many companies are inadvertently creating a “patchwork quilt” of tools that make up the development toolchain, which creates a complex developer experience.
VP of Product at GitLab
Companies are trying to unlock their digital transformation and, as part of this, allow individual teams to select their own tools. This results in companies building DIY DevOps toolchains: multiple tools stitched together and maintained by the company. Maintaining these toolchains is time- and resource-intensive and requires developers to learn multiple tools to perform their tasks. These toolchains are also costly and often slow down innovation as tool integrations can be fragile. Developers interact with everything from IDEs to CI/CD pipelines and security scanners.
DIY DevOps toolchains can also create artificial silos when teams within an organization use different tools. Developers are under tremendous pressure to develop secure code, but often are unable to collaborate directly with their security and operations counterparts before deploying applications into production. This leads to scalability issues, potential security vulnerabilities entering production and friction between teams.
Companies can streamline developer workflow by eliminating DIY DevOps toolchains, and adopting a complete DevOps platform. This reduces a number of stressors for all teams: developers, security and operations. Adopting a single application DevOps platform facilitates collaboration, reduces friction between teams and lowers security and compliance risks. The faster cycle times as well as improved metrics and reporting enable a seamless development process, and ultimately, fewer costs for the company as a whole, stronger business results and more innovation.
Vice President of Developer Network at Twilio
Without a doubt, the hardest part of crafting a great developer experience is progressively revealing complexity.
A superb first-time experience is essential when a developer is trying a new product or service. Developers’ time and focus is precious, so it’s imperative they see firsthand the value your product provides within their first minutes using it. The best experiences leave the developer excited to keep going.
At first, your product likely doesn’t do much beyond the core value proposition. Where things can go wrong is over the coming years: You continue investing in your product, add additional features and expand to new use cases. All of a sudden, it can be overwhelming for developers to know which parts of your platform are the parts they need.
The solution isn’t to educate developers on the entirety of your platform before they try any part of it — no developer has time for that. The best platforms craft a journey for developers, keeping the first-time experience crisp and delightful while progressively informing developers about more complex features as they continue building with the product.
Co-founder and CEO at LaunchDarkly
Developer experience is how developers interact with tools and processes to get their job — delivering exceptional, working products — done. It’s critical in ensuring developers can adopt, use and scale with a product.
Usability, scalability, compliance and reliance are foundational in delivering a great developer experience. For usability, clear and easy-to-understand documentation is a must, as are APIs and SDKs that make it simple for developers to begin using the product or platform. After getting installed and started using a platform, developers must be able to scale as they add more users, internally and externally. In building our feature management platform, we’ve made this a priority, helping thousands of customers with trillions of their features every day. Compliance is also a priority, helping earn the trust of developers that their platform’s data and security will be handled professionally.
The hardest part to get right is product or platform reliance, or the confidence a developer has in whether their questions and concerns will be quickly and professionally answered. This is crucial in addressing immediate bugs but also in ensuring future functionality. When connecting with a customer, I learned that as part of her evaluation, she would enter a support ticket and see how long it took to get a response. She was shocked to find that some vendors never responded. The developer experience extends beyond just functionality, and should be approached as a partnership in which vendors are continuously working to support their customers’ development teams in all aspects of their work.
Head of Strategy at DataStax
“How does our product fit into your greater workflow?" is a question that few companies think to ask or answer. We reward our teams for expertise in the narrow domain of whatever problem we solve - payments, messaging, video, analytics - which leads to cultures that produce inside-out solutions. "Here's what we have - you should use it like this."
Each developer is unique in their personal tools ecosystem. We must understand this fundamental truth to build great developer experiences. Their uniqueness, multiplied by the breadth of jobs to be done, makes it hard to conceive of outside-in solutions.
There are three key patterns that work:
- Everyone Works In Developer Support - everyone in your product & engineering team rotates through developer support, regardless of role, to understand the developer's world.
- Represent The Community In Your Team - each developer community you care about must have a representative from their world who advocates for their needs.
- Celebrate Open Source Glue Code - encouraging developers to contribute add-ons and "glue code" makes it easier for others like them to use your product - and helps you understand the rough edges in your developer experience.
Kevin McAllister ( @k__mcallister) is a Research Editor at Protocol, leading the development of Braintrust. Prior to joining the team, he was a rankings data reporter at The Wall Street Journal, where he oversaw structured data projects for the Journal's strategy team.
More from Braintrust