Working with developers can feel mysterious if you are not technical. One moment you ask, “Can we add a tiny button by Friday?” and the next moment the engineering team explains database migrations, edge cases, technical debt, API limitations, and something called “legacy architecture,” which sounds like a haunted mansion for code. That is exactly why SaaStr Podcast #419: How to Collaborate, Manage, and Work with Developers featuring Twilio’s Jeff Lawson still matters.
In the episode, SaaStr founder Jason Lemkin speaks with Jeff Lawson, the co-founder of Twilio and author of Ask Your Developer. Lawson is an unusual business leader because he speaks both languages: the business language of urgency, growth, customers, and revenue, and the developer language of systems, product quality, infrastructure, and careful problem-solving. That combination makes his advice useful for SaaS founders, product leaders, marketers, sales executives, and anyone who has ever stared at a Jira ticket wondering whether “in progress” means today, next week, or sometime before Mars colonization.
The big idea is simple but powerful: developers should not be treated as a production line for feature requests. They should be treated as creative problem-solvers who can help a company understand customers, build better products, and move faster without accidentally setting the product roadmap on fire.
Why This SaaStr Podcast Episode Still Feels Fresh
SaaStr Podcast #419 was released in 2021, but the topic has only become more important. Every company now has to think like a software company. Banks, retailers, healthcare providers, restaurants, logistics firms, and tiny startups selling oddly specific subscription boxes all rely on software to serve customers. The companies that know how to collaborate with developers can ship faster, learn faster, and adapt faster.
Jeff Lawson’s message is not “let engineers run everything.” It is more practical than that. His argument is that business teams should bring developers closer to the real problem. Instead of giving engineers a locked-down task list, leaders should explain the customer pain, the business goal, and the constraints. Then they should let technical people help shape the solution.
That shift changes the entire relationship. Developers stop feeling like order-takers. Product and business teams stop feeling like engineering is a mysterious cave where requests disappear. Everyone gets closer to the customer. And, ideally, fewer meetings end with someone saying, “Let’s circle back,” which is corporate language for “nobody knows what just happened.”
Who Is Jeff Lawson, and Why Does His Advice Carry Weight?
Jeff Lawson co-founded Twilio in 2008 with a developer-first idea: make communications programmable through APIs so builders could add voice, messaging, and other communication features without wrestling with old telecom complexity. That approach helped Twilio become one of the most recognized developer-platform companies in the world.
Lawson’s background matters because he did not simply manage developers from a distance. He was a developer himself, worked in product roles, and built companies before Twilio. In Ask Your Developer, he argues that developers are not just people who write code. They are creative professionals who can solve business problems when companies give them context, autonomy, and access to customers.
That belief is the heartbeat of SaaStr Podcast #419. The episode is not a generic “be nicer to engineers” pep talk. It is a playbook for building a healthier operating system between business leaders and technical teams.
The Core Lesson: Assign Problems, Not Tasks
The most important idea from the episode is this: assign problems, not tasks. A task sounds like, “Add a dashboard export button.” A problem sounds like, “Customers are spending two hours every Friday manually preparing reports, and they are threatening to churn unless we make reporting easier.”
The difference is enormous. A task tells developers what to build. A problem tells them why it matters. Once developers understand the “why,” they may suggest a better solution. Maybe the answer is not a button. Maybe it is an automated email, a redesigned reporting flow, a better API endpoint, or a simpler data model. In other words, the best technical solution may not match the first business request.
This is where non-technical leaders sometimes get nervous. Giving developers more room can feel like losing control. But in reality, it creates better control because the team is aligned around outcomes, not random feature demands. The product becomes less of a feature buffet and more of a system designed around real customer value.
Keep Developers Close to Customers
One of Lawson’s strongest recommendations is to bring developers closer to customers. At Twilio, the idea of developers understanding customer pain was not decorative wall art. It was part of how the company built products. When engineers hear customer problems directly, they can develop intuition that no requirement document can fully capture.
For example, imagine a SaaS customer says, “The upload process is slow.” A business team might translate that into, “Make upload faster.” But a developer on the call might notice something deeper: users do not actually need faster upload speed; they need clearer status feedback, resumable uploads, or a way to continue working while files process in the background. That insight comes from hearing the frustration directly.
Customer proximity also creates motivation. Developers are far more engaged when they know their work helps a real person. A bug ticket labeled “Fix issue #8472” is dull. A customer story saying, “This bug prevents a hospital team from confirming patient appointments” is a completely different emotional experience. Context turns code into impact.
Small Teams Can Beat Big Committees
Another key theme from SaaStr Podcast #419 is the power of small, focused teams. Lawson argues that progress often comes from a small group deeply focused on a customer problem. This is especially true in SaaS, where speed and learning matter more than theatrical planning rituals.
Large committees tend to create slow decisions, unclear ownership, and beautiful slide decks that age like milk. Small teams, by contrast, can move quickly when they have a clear mission, the authority to act, and direct access to feedback.
This does not mean companies should throw five people into a room and yell, “Innovate!” A strong small team still needs a clear goal, product context, engineering judgment, customer insight, and executive support. But once those pieces are in place, a small team can make impressive progress without dragging half the company into every decision.
Executive Enthusiasm Is Not Optional
Lawson also emphasizes something many executives underestimate: enthusiasm from leadership matters. Developers want to know that their work is important to the company, not just a hidden technical chore behind the “real business.”
When a CEO, founder, or senior leader personally communicates that a technical initiative matters, the message lands differently. It tells the team, “This is not a random feature request from a spreadsheet. This is central to where the business is going.”
That kind of executive support helps recruit talent, retain talent, and focus talent. Great developers often have options. They are more likely to stay where they feel trusted, challenged, and connected to meaningful work. Nobody dreams of becoming “the person who updates the dropdown menu forever.” People want to solve problems that matter.
Why Business Teams Miscommunicate with Developers
Most conflict between business teams and developers is not caused by bad intentions. It is usually caused by different mental models.
Business teams often think in terms of deadlines, revenue targets, customer promises, competitive pressure, and market windows. Developers think in terms of dependencies, maintainability, system design, security, performance, testing, and what might break at 2:17 a.m. on a Saturday. Both perspectives are valid. The trouble begins when either side assumes the other side is being unreasonable.
When sales says, “We need this feature for a major customer,” engineering may hear, “Please interrupt the roadmap again.” When engineering says, “This will take longer than expected,” sales may hear, “Engineering does not care about revenue.” The solution is not more corporate theater. The solution is better translation.
Good collaboration starts when both sides share context early. Sales should explain the customer value and urgency. Product should clarify priorities and trade-offs. Engineering should explain risks and options in plain English. Finance should understand that technical debt is not imaginary developer drama; it is future cost wearing a fake mustache.
How to Collaborate Better with Developers
1. Start with the Customer Problem
Before asking developers to build something, explain the customer pain. Who has the problem? How often does it happen? What is the business impact? What happens if nothing changes? The clearer the problem, the better the solution.
2. Share Constraints Honestly
Developers do not need fantasy timelines. They need real constraints. If a customer renewal depends on a fix, say that. If the budget is limited, say that. If a deadline is flexible, say that too. Honest constraints help teams make smart trade-offs.
3. Invite Engineers Earlier
Do not wait until the strategy is fully baked before bringing engineering into the conversation. By then, the plan may already contain expensive assumptions. Invite developers early, when their input can still shape the solution.
4. Avoid Solution Dumping
“Build exactly this” should be used carefully. Sometimes a specific request is fine, but when every ticket arrives as a pre-decided solution, the company loses engineering creativity. Let developers question the approach. That is not resistance; that is often where the better idea begins.
5. Explain the Business Model
Developers build better when they understand how the company makes money. Is the goal retention, expansion, activation, conversion, cost reduction, reliability, or compliance? The answer changes technical priorities.
6. Respect Deep Work
Software development requires concentration. Constant interruptions, surprise meetings, and “quick questions” can destroy productivity. A five-minute interruption can create a 30-minute recovery period. Protecting focus time is not a luxury; it is operational discipline.
7. Measure Outcomes, Not Keyboard Noise
Counting lines of code is a famously bad way to measure developer productivity. More code is not always better. Sometimes the best engineering work removes code, simplifies a process, or prevents a disaster customers never see. Better metrics include lead time, deployment health, customer impact, reliability, and team learning.
The Role of Developer Velocity
Developer velocity is not about forcing engineers to type faster, as if software quality improves when everyone drinks a suspicious amount of cold brew. It is about removing friction so developers can deliver useful software safely and consistently.
High-performing companies invest in tools, culture, architecture, and processes that help developers work well. They reduce unnecessary approvals, improve documentation, automate testing, create clear ownership, and encourage healthy collaboration between business and engineering teams.
This aligns strongly with Lawson’s SaaStr message. The point is not to worship developers or make every company an engineering monastery. The point is to understand that developers are a scarce, valuable, creative workforce. When organizations waste developer time, they waste product opportunity.
What Non-Technical Leaders Should Stop Doing
Non-technical leaders can dramatically improve collaboration by cutting a few bad habits.
First, stop treating estimates as promises written in stone. Software estimates are forecasts under uncertainty. A developer can estimate based on known information, but hidden complexity often appears once work begins. A healthy team updates estimates as it learns.
Second, stop using urgency as a substitute for priority. If everything is urgent, nothing is. Developers need a clear stack-ranked order of what matters most. “All of these are P1” is not prioritization; it is panic wearing a blazer.
Third, stop bypassing product and engineering processes for every loud customer. Important customers deserve attention, but constant roadmap hijacking creates chaos. The better move is to evaluate customer requests against broader strategy, revenue impact, user value, and technical cost.
Finally, stop assuming “simple” means “easy.” A feature may look simple on the screen while requiring complex changes behind the scenes. The visible interface is often the tip of the iceberg. The database, permissions, integrations, analytics, testing, and edge cases are the iceberg’s angry underwater relatives.
What Developers Should Also Understand About Business Teams
Lawson’s advice is not one-sided. Developers also need to adapt. Business urgency is real. Customers do leave. Competitors do move. Revenue does matter. A technically elegant solution that arrives too late may fail the business, even if the architecture diagram deserves a museum exhibit.
Developers can collaborate better by explaining trade-offs clearly. Instead of saying, “No, that is impossible,” try, “We can do a simple version in two weeks, a scalable version in six weeks, or a risky shortcut in one week that may create support issues later.” That turns a technical objection into a business decision.
Engineers should also learn the language of customer impact. A non-technical executive may not understand why refactoring matters. But they will understand, “This improvement will reduce outages, speed up future feature development, and lower support tickets.” Translation is a superpower.
How SaaS Companies Can Apply the Episode’s Lessons
For SaaS companies, SaaStr Podcast #419 offers a practical framework. Start by auditing how ideas move from customer feedback to product decisions to engineering work. Where does context disappear? Where do developers receive tasks without understanding the user problem? Where do business teams make technical assumptions too early?
Next, create rituals that bring developers closer to customers. Invite engineers to selected customer calls. Share support-ticket patterns. Ask developers to review churn reasons. Let them see product analytics. Encourage product managers to write problem briefs instead of feature commands.
Then, improve the way teams make trade-offs. Every meaningful product decision involves trade-offs between speed, quality, cost, scope, and risk. Strong teams make those trade-offs visible. Weak teams hide them until launch week, when everyone suddenly discovers the product cannot do the thing that was promised in a sales deck three months ago.
Finally, celebrate engineering wins in business terms. Do not only praise the launch. Praise the reliability improvement that reduced support volume. Praise the internal tool that saved account managers hours. Praise the API cleanup that made partner integrations easier. When developers see that the company values invisible work, they become more invested in visible outcomes.
Common Mistakes When Managing Developers
Micromanaging the How
Leaders should be deeply involved in defining goals, priorities, and constraints. But micromanaging implementation details usually backfires. Developers need room to make technical decisions based on expertise.
Ignoring Technical Debt
Technical debt is the cost of past shortcuts. Some debt is acceptable, especially in startups. But ignoring it forever is like never changing the oil in a car because the car is “still moving.” Eventually, the engine files a complaint.
Separating Builders from Users
When developers never meet customers, they build from secondhand information. That can work for small tasks, but it weakens product intuition over time. Customer exposure helps engineers make better micro-decisions every day.
Confusing Activity with Progress
A busy engineering team is not always a productive engineering team. Lots of tickets, meetings, and code changes may still produce little customer value. The real question is whether the team is solving the right problems.
A Practical Collaboration Framework Inspired by Jeff Lawson
Here is a simple framework any SaaS team can use after listening to SaaStr Podcast #419.
Step one: Define the problem. Write a short problem statement in plain English. Include the customer segment, pain point, evidence, and business impact.
Step two: Bring in engineering early. Ask developers what they see. What is easy? What is risky? What alternatives exist? What hidden dependencies matter?
Step three: Decide the outcome. Agree on what success looks like. It might be lower churn, faster onboarding, fewer support tickets, higher activation, or better reliability.
Step four: Choose the smallest useful solution. Do not build a cathedral when customers need a working door. Start with a focused solution that creates value and teaches the team something.
Step five: Review and learn. After launch, compare results with expectations. Did the solution work? What surprised the team? What should change next?
Why This Matters More in the AI Era
AI tools are changing how software gets written, reviewed, and shipped. But they do not remove the need for developer collaboration. In fact, they make it more important. When code can be generated faster, teams need even clearer judgment about what should be built, how it should be tested, and whether it solves a real customer problem.
The future belongs to teams that combine business insight, engineering creativity, and customer empathy. AI may accelerate execution, but it cannot replace product judgment. A bad idea delivered faster is still a bad idea, just wearing running shoes.
Lawson’s message fits this new environment perfectly. Developers should not be hidden away as code producers. They should be involved as partners in problem-solving. The companies that learn this will build better software. The companies that do not may ship more features while creating more confusion.
Real-World Experience: What Working with Developers Actually Teaches You
One of the biggest lessons from working with developers is that clarity is kindness. A vague request creates stress for everyone. Business teams become frustrated because the result does not match what they imagined. Developers become frustrated because they are asked to read minds, and mind-reading has poor documentation.
In practice, the best collaborations begin with a conversation, not a ticket. For example, a marketing team might ask for a landing page personalization feature. If that request goes directly into a backlog as “Build dynamic landing pages,” the engineering team may estimate a large project. But if the teams discuss the real goal, they might discover that marketing only needs three audience-specific page variants for one campaign. That can become a much smaller project with faster impact.
Another experience: developers often spot operational risks before anyone else. A sales team may promise a custom integration because it seems like a great way to close a deal. An engineer may notice that the integration will require ongoing maintenance, special permissions, security review, and support documentation. That is not negativity. That is risk visibility. Smart companies welcome it.
Working with developers also teaches patience with complexity. Software is full of invisible dependencies. Changing one field in a form may affect reporting, billing, permissions, analytics, mobile display, API behavior, and customer support scripts. To outsiders, this can look ridiculous. To engineers, it is Tuesday.
The best teams build trust by making complexity visible without turning every explanation into a graduate-level computer science lecture. Developers should explain enough for business teams to make informed decisions. Business teams should respect the fact that software systems have consequences beyond the visible screen.
A healthy collaboration culture also makes room for disagreement. Some of the best product decisions come from respectful tension. Sales pushes for customer urgency. Product pushes for strategy. Engineering pushes for feasibility and quality. Customer success pushes for adoption and supportability. When those voices are aligned around the same problem, disagreement becomes productive instead of political.
One especially useful habit is writing decision notes. After a major product or engineering decision, the team records the problem, options considered, trade-offs, and final decision. This prevents future confusion and helps new team members understand why something was built a certain way. It also reduces the classic workplace mystery: “Who decided this?” followed by twelve people suddenly inspecting their coffee.
Another practical experience is that developers appreciate being trusted with business context. Many leaders assume engineers only want technical details. In reality, strong developers often want to understand market pressure, customer behavior, revenue impact, and company strategy. That context helps them make better decisions when nobody is watching.
Finally, the best developer collaboration feels like a partnership. The business team does not throw requests over the wall. Engineering does not hide behind technical language. Both sides work together to understand the customer and choose the smartest path. That is the spirit of SaaStr Podcast #419 and the enduring value of Jeff Lawson’s advice: ask your developers, not because they have every answer, but because they can help find better answers than the company would find without them.
Conclusion
SaaStr Podcast #419: How to Collaborate, Manage, and Work with Developers featuring Twilio’s Jeff Lawson is more than a podcast episode about engineering management. It is a reminder that software is now central to how modern businesses compete. Developers are not a back-office resource waiting for instructions. They are creative problem-solvers who can unlock growth when they understand the customer, the business goal, and the constraints.
The best leaders assign problems, not tasks. They keep developers close to customers. They build small, focused teams. They communicate priorities clearly. They give engineers room to solve, question, and improve. And they remember that collaboration is not about making everyone agree instantly. It is about creating enough trust, context, and shared purpose for better decisions to emerge.
In a world where every company is becoming more digital, the ability to work well with developers is no longer optional. It is a competitive advantage. Ask your developer. Then listen carefully. The answer might save your roadmap, your customer relationship, and possibly your next all-hands meeting.
