Improving Developer Experience Through Platform Engineering

Want your platform teams to be engines of margin expansion and not line items of infrastructure cost? Developer Experience (DevEx) remains one of the most underleveraged levers for improving return on invested capital (ROIC) in large enterprises, especially those not born digital. In every CTO role I’ve held, modernizing DevEx has been critical to scaling innovation, shortening time-to-market, and reclaiming the 20–30% of engineering time lost to undifferentiated work. When I joined Amazon in 2014, the bar was clear: new hires shipped code to production by the end of Week 1. That kind of velocity was engineered: -Infrastructure as code for consistent setup -Opinionated tooling like Brazil, Apollo, Pipelines -Platform teams owning everything from build to release gating Centralizing undifferentiated effort into shared infrastructure made speed, scale, security, and quality the default across teams. Fast forward to this summer: my daughter Riya interned at Amazon. On Day 2, she called me: “The tools here are wild. I’m already doing code reviews.” I’m a proud mom of this bright and hardworking intern, and I also know those foundational systems are now even better. That’s what compounding platform investment looks like. Yet across many enterprises, DevEx initiatives still struggle to gain CEO sponsorship—largely because we’ve lacked a clear way to measure return. That’s why I’m excited about Amazon’s new framework: 📊 Cost to Serve Software (CTS-SW) A financial model for measuring and improving ROIC from DevEx investments. It answers: how much does it cost us to deliver one unit of working software to production? CTS-SW=Development Costs + Dev Infrastructure Costs/Software Delivery Units Lower CTS-SW signals higher platform efficiency and stronger ROIC from every dollar invested in DevEx—whether you're streamlining onboarding, accelerating deployments, integrating AI-assisted development, reducing tech debt, or scaling service ownership with better observability and tooling. CTS-SW also aligns central and federated teams to customer outcomes, breaks down silos, and frees engineers from undifferentiated work so they can focus on high-leverage innovation. In 2024, Amazon saw: -15.9% ↓ cost to build and operate software -18.3% ↑ deployments per developer (YoY) -For example, in a 1,000-dev org: that's a $20M annual efficiency gain For CTO/CIOs: CTS-SW bridges engineering productivity with financial performance For CEO/CFOs: it offers a data-backed lens to fund DevEx as a lever for margin expansion If you're building platform teams or modernizing software delivery, this is a framework worth your attention. Thanks Jim Haughwout Full article: https://lnkd.in/eiTrznxd #DeveloperExperience #ROIC #GenAI #CTO #CIO #CFO #CEO

❌ "Build it and they would come" Is the most common (and incorrect) mindset I've seen people have whilst building Enterprise patterns in Platform Engineering. Focus on the "wins": When evangelizing platform engineering patterns, prioritize demonstrating tangible benefits to developers on their immediate projects. This could include: ✔ Reduced development time: Show how using the pattern cuts down on boilerplate code or repetitive tasks. ✔ Improved code quality: Explain how the pattern leads to more maintainable and scalable code. ✔ Simplified deployments: Highlight how the pattern enables smoother integrations and easier deployments. ✔ Increased developer productivity: Point out how the pattern empowers developers to focus on core features instead of infrastructure concerns. By focusing on specific, quantifiable improvements that directly impact developers' day-to-day work, you'll have a much stronger case for adopting platform engineering patterns. Remember, developers care most about tools that make their lives easier and their work more impactful. #platformengineering #cloudnative #devops #softwareengineering #patterns

Last month, engineering leads at Duolingo held our first “engineerication.” (I got the idea from Stripe.) Basically, we took a week off from our regular jobs to sit together and code in order to see what our engineers do daily, get back into the tech stack to see what can be improved. 👩💻 Turns out, a lot has changed in the years since I last wrote a line of code 😅Some things have gotten much easier. Codespaces, for example, allows engineers to easily create a coding environment in the cloud instead of on their local machines. And GitHub Copilot auto-suggests chunks of code. But there were 3 big takeaways I had for how we can improve our engineers’ experiences: 1. On the first day, I set out to do a few small code changes. But as a new engineer, you can’t just sit down and make a change immediately, even a tiny one. You have to set up your environment and figure out where the code needs to go. Then you have to build the code, test it, get it reviewed, and push it live to production. All of this takes time—sometimes, too much time. I want to make it easy for new software engineers to be productive right away without having to set up their development environment or having to learn a lot of arcane tools, processes, and magical incantations. 2. When I started at Duolingo nine years ago, we had a few GitHub repositories. Now we have dozens of microservices. This means that even a small code change may require updates to several repositories. If you’re not regularly working in a given repo, this is much harder, especially if it’s one that your team doesn't own. More standardization is needed to make it easier to code across our various microservices and client repos (we’re starting to do this, but more can be done!) 3. Code review turnaround time slowed us down. We averaged about a 24-hour turnaround, but when making atomic (easily revertable) pull requests, lots of PRs stack up and eventually lead to merge conflicts, etc. In practice, I could see engineers cutting their turnaround time by making PRs that are less atomic, which leads to messier reverts and a harder time diagnosing bugs. Whenever software engineers are tempted to take shortcuts because the current process is too slow or painful, that’s an opportunity for improvement. Overall, taking a week to go hands-on with the code is a great way to build better processes and teams. It was an incredibly valuable week that helped us visualize the steps we can take to remove pain points and speed up some unnecessarily slow processes. 🐢 (One more learning: Next time, I’m going to invite one of our software engineers to pair program with me 😅) Help us develop new products and processes! We're hiring: https://lnkd.in/eSJYjYPG #engineering #processimprovement #leadershipidea

In the last few years, many modern tech companies have started a developer experience (DX) team, all with a common goal - enhancing developer collaboration. For those of you venturing into this domain, here are 7 tips to kickstart your DX journey: 1) Treat your DX team as a product team, where developers in your company are your customers. You must regularly talk to them and seek their feedback relentlessly. 2) Start by just setting up a rants channel on Slack, this will give you enough feedback to start creating a backlog. 3) Internal surveys are also a great way to collect feedback, just put together a Google form, and leave some space for subjective responses. 4) Early setup of instrumentation is pivotal. To convince the leadership you must show the impact. Getting your DORA metrics in place is a good start. 5) Developer productivity is not about individual metrics. Your goal is to reduce friction that’s slowing down teams, not try to measure who is working the hardest 6) You must learn to say “No” often. DX teams commonly become a “catch-all” team dealing with upgrades and improvements for projects that no one else wants to do. 7) Many of your efforts would require social engineering - asking developers to adopt new ways of doing things and convincing leadership that this is worth the effort. If you are excited to learn more about improving DX in your company, join our vibrant community at dx.community. Let's collaborate and transform the developer experience together. #developerexperience #devex

𝐌𝐚𝐧 𝐩𝐫𝐨𝐩𝐨𝐬𝐞𝐬, 𝐆𝐨𝐝 𝐝𝐢𝐬𝐩𝐨𝐬𝐞𝐬 ⚡️ Platform developers can make plans, but Platform Users determine how things with turn out. A platform can be super-optimised and feature-rich but ultimately fail if it doesn’t get adopted—as good as any other inert product. 🎯 𝐇𝐨𝐰 𝐝𝐨 𝐁𝐞𝐬𝐭-𝐢𝐧-𝐂𝐥𝐚𝐬𝐬 𝐃𝐚𝐭𝐚 𝐏𝐥𝐚𝐭𝐟𝐨𝐫𝐦𝐬 𝐒𝐭𝐫𝐚𝐭𝐞𝐠𝐢𝐬𝐞 𝐀𝐝𝐨𝐩𝐭𝐢𝐨𝐧? Here are a couple of recommendations from our Chief Architect to get this going. 🔦 𝐋𝐢𝐠𝐡𝐭 𝐮𝐩 𝐭𝐡𝐞 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞 𝐩𝐚𝐭𝐡 ------------------------------------- 1. 𝘋𝘦𝘴𝘪𝘨𝘯 𝘯𝘰𝘵 𝘫𝘶𝘴𝘵 𝘵𝘩𝘦 𝘱𝘭𝘢𝘵𝘧𝘰𝘳𝘮, 𝘣𝘶𝘵 𝘢𝘭𝘴𝘰... Approaches and frameworks to use your platform. This could be in the shape of approach templates like Kanban & Agile on JIRA or Data Products on DataOS 2. 𝘊𝘳𝘦𝘢𝘵𝘦 𝘌𝘹𝘱𝘦𝘳𝘪𝘦𝘯𝘤𝘦/𝘑𝘰𝘶𝘳𝘯𝘦𝘺-𝘉𝘢𝘴𝘦𝘥 𝘋𝘰𝘤𝘶𝘮𝘦𝘯𝘵𝘢𝘵𝘪𝘰𝘯. The user doesn’t want to learn a new ecosystem unless they have comfortably penetrated into it enough to see one layer of value. 3. 𝘎𝘪𝘷𝘦 𝘢 𝘧𝘭𝘢𝘷𝘰𝘶𝘳 𝘰𝘧 𝘞𝘩𝘢𝘵’𝘴 𝘐𝘯 𝘐𝘵 𝘍𝘰𝘳 𝘛𝘏𝘌𝘔 (𝘞𝘐𝘐𝘍𝘛), 𝘢𝘬𝘢, 𝘵𝘩𝘦 𝘜𝘴𝘦𝘳 My mind, as a user of any product/process, naturally resists new habits. I want to know what I’m getting into first. This could be done in several ways, such as guides on platform IDEs, interfaces, and other toolkit. 💉 𝐏𝐞𝐧𝐞𝐭𝐫𝐚𝐭𝐢𝐧𝐠 𝐢𝐧𝐭𝐨 𝐞𝐱𝐢𝐬𝐭𝐢𝐧𝐠 𝐡𝐚𝐛𝐢𝐭𝐬 ------------------------------------- 1. 𝘒𝘦𝘦𝘱 𝘪𝘵 𝘧𝘢𝘮𝘪𝘭𝘪𝘢𝘳 This doesn't mean duplicating your user's tools/platforms, but rather to be inspired by their day-to-day working frameworks. How often do they jump tools? Is that easier for them compared to a unified self-service layer? What's the semantic convention they can just skim with the lowest friction? 2. 𝘌𝘹𝘵𝘦𝘯𝘥 𝘵𝘰 𝘯𝘢𝘵𝘪𝘷𝘦 𝘦𝘯𝘷𝘪𝘳𝘰𝘯𝘮𝘦𝘯𝘵 In any real-world scenario, your platform is, after all, like a new colleague to all other entities in the data stack. How quickly can it accommodate, adapt, and scale to a position where it enables others? For a deeper dive into these points and more, access this brief and breezy piece by Travis Thompson 🥷🏻 here: https://lnkd.in/dTXjtg44 #dataengineering #dataplatforms

🔍 The Critical Lesson: Developer Questions Matter! In one of my early projects, I presented what I thought was a flawless design. The developers, however, bombarded me with questions that I felt were unnecessary at the time. I quickly realized how wrong I was. Developer questions are VERY important and should never be taken lightly. It was an eye-opening moment. Developers have a different perspective, focusing on feasibility, functionality, and implementation. Their questions are not just queries but essential insights that can make or break a project. Here’s how I embraced this lesson: 👍Collaborative Approach: I started involving developers early in the design process. Their input helped foresee potential issues and align the design with technical realities. 👍Valuing Feasibility: I began to appreciate the importance of feasibility in design. A brilliant design that can’t be implemented is useless. 👍Iterative Feedback: I encouraged continuous feedback loops between designers and developers. This ensured that the design evolved in harmony with development constraints. What happened next? ➡️➡️➡️ We delivered a product that was not only visually appealing but also robust and functional. The development process was smoother, and the final product was better for it! This experience taught me to value and respect the developer’s perspective. Their questions are crucial for bridging the gap between design and execution. --- ❓How do you handle developer feedback in your projects? ❓Have you had a similar experience where developer insights significantly improved the outcome? #UXDesign #Collaboration #ProductDesign #DeveloperInsights #UX #software

It's hard to know where to dig in as a new Web Platform engineer, so I encourage folks to fix papercuts and inconsistencies; some that haven't been tackled yet but will give you the "full tour" of moving a feature through the Blink process: - `loading="lazy"` for <audio> and <video> - `async` and `defer` for *all* elements that fetch - `alt` for more media types - `buffered` for animated image types - a thumbhash `poster` attribute for <img> and <video> - ImageData constructor in Paint Worklets - `integrity` (SRI) for all media types, particularly images - `loop` and looping controls for animated images Some are more adventurous than others, but all would be big quality of life improvements for web developers.

We recently released lifecycle reporting in DX, and I’ve loved seeing it help Platform teams build a concrete business case for funding important Platform and DevEx initiatives. While traditional metrics—like build times, pull request merge times, and issue cycle times—offer useful insights, they cover only a narrow slice of developer workflows. They also often fail to distinguish between non-blocking delays (where developers can switch context and stay productive) and true friction points that drain valuable engineering time. Lifecycle reporting helps pinpoint where in the development process teams are experiencing the most friction and delays—and ultimately costing organizations the most. Just like in the screenshot below, I’m seeing companies lose thousands of engineering hours each year to challenges understanding existing code, lengthy CI processes, dev environment issues, and excessive meeting schedules.

Want happy developers? Prioritize these 3 things. Flow. Feedback. Cognitive Load. A very insightful 2023 study published by the Association for Computing Machinery breaks optimal developer experience down into these three practical dimensions: 1. Flow state. Developers do their best work when they can get into the zone. Anything that creates interruptions means that they're taken out of flow state and unable to do their best problem solving. 2. Feedback loops. Devs like to have short feedback loops. Problem solving is inherently an iterative exercise and you want fast iterations. The faster you get feedback, the faster you can move onto the next iteration. Devs get frustrated if code is sitting there for weeks before moving into production. 3. Cognitive load. Even though a developers job is to code, there are many other things they have to deal with that's irrelevant to solving their code problem — e.g. learning the internals of Kubernetes or having to figure out a deployment script someone wrote 5 years ago. All of these things create cognitive load that slows them down. Agree/disagree? What other factors need to be highlighted? #DevelopersExperience #DevEx #Developer

90% of all advice I see on LinkedIn for Developers is all about how to be more productive, but no talks about this: → Developer Experience. Yes, Developer productivity is important, but not more than DX……. You see, Developer Experience (DX) is all about, how engineers feel about the environment they use to build software. This environment includes tools, frameworks, efficient processes, and everything. The environment a developer is working in is directly responsible for their: - creativity  - productivity - and overall work impact There’s a big reason that top tech companies like Meta, Amazon, and Google ship releases so fast: they all have spent time cultivating a good DX. Strong DX = Happy Developers = Better Products = More Revenue & Growth. Because happy developers are productive developers. Here's how to optimize DX at your workplace: 1. Understand the current situation ➥ talk to your developers!  ➥ they'll give the best review of their experience. ️ ➥ run DX surveys to gather data & track the progress 2. Make a platform team. ➥ Create a dedicated team with one focus ➥ providing internal developer services that make life easier. ➥ examples:  infrastructure, CI/CD pipelines, or clear documentation With these 2 things, you can easily make a DX platform. With it, you can: - reduce complexity - promote learning   and do so much more….. All the advice is valid on productivity but it won’t work unless you give devs a proper environment. – P.S: As a developer, how would you rate your developer experience (1-10)?