Dana Lawson on Leading Global Engineering Teams

Metrics don't kill culture. A lack of trust does. 📉 When engineering leaders introduce new KPIs or DORA metrics, the room usually goes quiet. The immediate fear? "Are these going to be used against us?" 🤨 In the latest episode of Braintrust, our CTO Ganesh Datta sits down with Randy Shoup, SVP of Engineering at Thrive Market, to discuss the delicate art of building a Reliability Culture. Randy’s secret to moving from a "pathological" organization to a transparent one? Vulnerability. If you’re trying to build a data-driven engineering org without losing the trust of your devs, this is a must-watch. 🎧 Listen to the full episode here: https://lnkd.in/gAjVTdgD

Most founders think we walk in and start talking about code. We don’t. The first 30 days are about clarity, not commits. We sit with leadership, not engineers. We map how money moves through the business. We find where technology slows it down. Then we build a roadmap that makes financial sense, not just technical sense. It’s the difference between “let’s build features” and “let’s drive results.” That’s why boards notice a difference before a single line of code changes.

Ever launched a "surefire" feature only to watch it tank your entire sprint? Three years back, I was heading up a team building a real-time analytics dashboard for our SaaS platform. We had buy-in from stakeholders, a tight deadline, and my grand vision of seamless data flows. I pushed hard—skipped thorough prototyping, overlooked edge cases in our event streaming setup, and dismissed a junior engineer's quiet concern about scalability under peak loads. Launch day: Chaos. The system buckled under 10x expected traffic, costing us $50K in downtime and a week's rework. Customers churned. My ego took the biggest hit. The brutal truth? As leaders, we chase momentum at our peril. That failure drilled home the power of "pause points"—mandatory 20% time buffers for spikes, prototypes, and devil's advocate sessions. No more heroics. Now, every project kicks off with a "what could kill us?" workshop. We've shipped 5x more reliably since. It reframed leadership for me: Protect the team from your own blind spots. What's the tech project failure that shaped your leadership style? Share below—let's swap war stories. #TechLeadership #SoftwareDevelopment

⭐ My team wasn’t broken. The container was. A few years ago, I led a team that looked fine on paper. Delivery was “okay”. Roadmaps were moving. No one was openly unhappy. But everything felt overloaded. Every sprint was overflowing. Every incident felt critical. Every request was “high priority”. It looked like a capacity problem. It was actually a container problem. 🔧 The moment I realised the container was wrong One planning session, I zoomed out and mapped all active work on a board. Features. Tech debt. Experiments. Support. Random “quick asks”. It was ridiculous. We had given ourselves a bucket big enough to hold everything, so of course stakeholders kept pouring everything into it. The team was not failing. The container we designed for the work was. That day I stopped asking, “How do we fit more in?” I started asking, “How small can we make the container and still hit what matters?” 🎯 What I changed I shrank the container on purpose: 🔹 We cut the number of active initiatives. 🔹 We capped work‑in‑progress. 🔹 We made “no” and “not now” part of the vocabulary. 🔹 We created visible capacity limits per sprint and per quarter. 🔹 We reserved real slack for incidents, learning, and refactoring. The team did not change. The expectations around them did. Within two months: • Fewer dropped balls • Better engineering quality • Clearer tradeoffs with Product • Less rework • Noticeably calmer people Same engineers. Smaller plate. 🧠 What this really means for engineering leaders We often try to “fix” people or add more people. Most of the time, we just need to fix the container we ask them to live in. If everything always feels overloaded, start by shrinking the bucket, not stretching the team. 🔁 If this resonates, a repost might help more leaders rethink how they design their team’s container. 💬 What is one thing you removed from your team’s container that made everything easier? #EngineeringLeadership #TeamCulture #LeadershipInTech #SoftwareEngineering #OrgDesign

🎙️ In this episode of Leaders of Code, our Chief of Product and Technology Jody Bailey sits down with Netlify's CTO Dana Lawson to explore her insights on leading lean, global engineering teams, and how AI is lowering the barrier to entry for builders everywhere. https://lnkd.in/eUbCMxis

Your Team Isn’t Too Slow. Your Decisions Are. Most "velocity" problems aren't engineering problems. They're decision problems. Unclear priorities. Too many dependencies. Endless loops of “let’s circle back.” Fix the real bottleneck: → Clarity. → Constraints. → Courage to say no. Speed starts before the first line of code. What’s one thing slowing your team down that isn’t technical? #ExecutionMatters #DecisionVelocity #TeamClarity #TechOps

📢 New post is live! Why should your most expensive engineers sometimes work on your “simplest” problems? Find out in this month’s Tech Team Talk, where Karol reflects on delegation, context, and what happens when teams rediscover where the real value lives. 🔗 Link in comments And go follow Karol on Substack — he writes Engineering Leader’s Playbook, where he shares lessons from real experiments with his teams. #engineeringculture #softwareteams #productthinking #techwriting

The CTO Gauntlet, What Actually Matters at Series B The CTO who built your product from zero to Series B might be the same person holding your company back from Series C. Not because they're not brilliant. Because the role fundamentally changed and nobody told them. In this briefing, I break down: → The player-to-coach trap that kills engineering velocity → 4 signals your CTO can't make the transition → The framework for navigating the hardest conversation in a scaling company Watch before your next board meeting: [Link in first comment]

Meet Adi Shacham-Shavit March 27! One of the special things about this conference is the chance to meet international heavyweights in a small, community-driven setting. Not a huge stage. Not hundreds of people in the audience. Instead: a room of engineering leaders, curious conversations, and the chance to actually spend time with the speakers. Our speakers are here to be part of the community for the afternoon, discussing ideas, answering questions, and sharing the real stories behind scaling engineering organizations. To make the most of that, take 10-20 mins to prepare and find the questions you want to discuss. 👇🏽 👋🏽 One of the speakers we’re very excited to welcome is Adi Shacham Shavit. Adi has more than 20 years of experience building and scaling engineering organizations in companies such as LivePerson and AppsFlyer, where she experienced hypergrowth first-hand, including scaling from 200 million to 20 billion events per day. Her leadership always starts at the intersection of technology, organization, and business, looking at architecture, teams, ways of working, and business needs as one connected system. She has worked across technologies from Python to Clojure, holds an MBA from the Technion, and today is Engineering Director at Enpal in Berlin. Adi is also a leader in LEAP, a VP Engineering leadership program, honestly the kind of initiative we wish existed in Sweden. 📺 Get to know her leadership views, watch this 20 mins DevOpsDays presentation: https://lnkd.in/dZaYm4Nk In the talk she shares a simple but powerful framework: there are three kinds of scale. • Traffic scale: when systems must handle growing load and complexity • Team scale: when organizations grow and processes, knowledge sharing, and architecture must evolve • Territory scale: when companies expand into new markets with new regulatory and technical constraints Or as Adi puts it: “You should not only understand how to scale your system, but also how to scale your team to support the company needs.” Take 20 minutes, watch the talk, and come ready with questions. That’s when this kind of small conference format really becomes powerful.

Most technology leaders don't realise it's happening until it's already in their codebase. The Shadow Dev Problem isn't about the tool. It's about what happens when half your team uses it and half doesn't. #ClaudeCode #AIAdoption #EngineeringLeadership #SoftwareDevelopment #AIStrategy Steven Muir-McCarey