Integrating Customer Focus into Engineering Teams

Your engineers can’t build for users they never meet. Get them closer, and your hardware business will see the difference. Too often, embedded engineers design for an abstract spec sheet instead of real people. They get requirements, test cases, and lab data but never see user stories. That’s a problem. As an embedded engineer, I have been on teams without access to users, and something was clearly missing. Some of the features we built were never used, because they weren’t the right ones. Worse, the feedback loop was so slow that we never got to feel the ratification of knowing out work was making a difference. This was a big hit to motivation! When engineers sit in on user calls or watch devices used in real-world settings, their approach shifts. They stop optimizing for what checks the box in the lab and start building for what works in real life. Give your engineers direct access to users, and you’ll be amazed at the results. Try this: • Rotate engineers through the support queue so they hear user pain points firsthand. • Have them join user studies to see how people actually interact with the product. • Encourage them to watch sales and customer success calls to understand real-world needs. The best hardware isn’t just built right— it’s the right thing to build. Memfault can help you take it a step even further. Learn more: https://lnkd.in/e3iPXRwD

Our engineering team works directly with customers in dedicated Slack channels. No middlemen 🙅♂️ When customers and developers can connect directly, it creates a cycle of immediate improvement. Our engineers witness problems firsthand, fix them faster, and build features based on actual usage patterns rather than guesswork about what customers might want. Once, a customer struggled with an EIP-712 transaction. The error wasn't obvious from our logs, but within minutes, our engineer identified the issue and helped them resolve it. We also spotted a recurring bug and built a minor feature update based on our findings. Not every company can or should expose its engineering team this way. It requires mature developers who communicate well, set clear boundaries around response times, and provide explicit documentation of feature requests versus quick fixes. The payoff is huge, though: engineers build with real users in mind rather than abstract personas. Our transaction success rates and reliability metrics have improved since implementing this system. Direct customer-to-engineer communication shouldn't be a revolutionary concept. It should be standard for infrastructure companies that are really serious about building solutions.

A few years ago, an engineer on my team suggested rebuilding one of our core systems. His reasoning? “It will be easier to maintain in a new language.” On the surface, it sounded reasonable. But when we dug into the details, the problem wasn’t the language at all. It was that we couldn’t easily identify customer data during debugging. The “rebuild” would have been a huge effort—and it wouldn’t have solved the real issue. This is exactly why the “working backwards” approach at Amazon is so powerful. You start with the customer, clearly define the problem, and only then explore solutions. Skip straight to the solution, and you risk building something impressive but ultimately irrelevant. For engineers, this process can feel unfamiliar. We’re trained to think about capabilities: new frameworks, architectures, and technologies. But the real value comes from understanding the customer and the specific impact of the problem. How long does a process take for them? How does it affect their experience? How can we measure improvement? Once the problem is clearly defined, multiple solutions can be explored and compared. Each comes with its effort, benefits, and trade-offs. This makes prioritization much clearer, and ensures that the work you invest actually delivers measurable value. Working backwards also helps your team claim credit for the impact they create. When you tie your work directly to improvements for customers, everyone sees the value added, and the team can continue focusing on the things that truly matter. I go into this process in more detail in my article, with examples and practical steps for applying it in engineering teams. If you want a structured, practical way to ensure the work you do actually solves real problems, it’s worth checking out.

Today I couldn’t be more proud. Not because we shipped something. Not because we closed a deal. But because our stand-up went for an hour and it wasn’t about bugs or sprints. It was about pricing. Yeah, pricing. Packaging. Distribution. And the people leading that convo were engineers. One of them literally asked: "But wait, if we move that into a paid plan, how will it affect onboarding speed?" Another said: "We need to know how this will be pitched because if it doesn’t land in a demo, what’s the point?" This is not a team that just builds features. This is a team that cares how it gets into people’s hands. They challenge our pricing because they understand GTM. They don’t wait for a PM to explain context. They ask, research and poke holes in assumptions themselves. And that’s why, right now, I don’t need a traditional product manager on the team and I'm not sure if I will need them in the next year. Because when your team owns the impact, they design for outcomes, not just tickets. Try getting this at a late-stage company. Where people drop features to marketing people so they can explain those to customers and sales people. Teams disconnected from results. Optimizing backlog velocity instead of business velocity. So how do you build a small, lean, result-oriented team like that? -> Hire builders who are curious about customers, go-to-market and how value gets created. Folks who have an ambition to go beyond their coding skills. -> Give them context, not tasks. Walk them through the “why” behind every decision. Make them part of it. -> Show them the impact. Every little win. Every user quote. Every conversion jump. -> Cut the fluff. No status meetings. No slide decks. Just one simple question: What are we trying to achieve this week and how do we know it worked? -> Protect the feedback loop. Keep engineers close to customers. Let them hear the pain. It changes everything. It’s not magic. It’s just a different kind of team. And once you taste this level of alignment, you never want to go back.

Jose Bergiste has seen companies waste MILLIONS because marketing and engineering work in silos. Nobody understands the customer. Everyone blames each other when projects fail. He shared his framework for building teams that actually collaborate. BACKGROUND: Jose has years of experience managing technical teams. He told me about a conversation that happens constantly: Marketing after six months: "This isn't what we wanted." Engineering: "That IS exactly what you asked for." Both are right. Both wasted six months. Marketing treated engineering like a vending machine. But Jose said that's not how software works. And most companies are missing software's biggest advantage. Here are 6 ways Jose builds teams that actually work: 1. Share Problems Not Solutions Jose compared bad requests to his old doctor who said "take this drug" with no explanation. His current doctor asks tons of questions first. Engineers need the same. Don't say "build a dashboard with these widgets." Say "customers can't find X and it's killing conversions." Context lets engineers solve the real problem. 2. Stop Treating Software Like Construction This is the big one most companies miss. You treat software like a building. One blueprint. One six-month build. Then you deliver and customers don't want it. Jose said software is fluid. Ship small pieces. Get real feedback. Change direction. When you do one massive build you waste its biggest advantage. The ability to adapt. 3. Build Overlapping Knowledge Jose creates Engineering 101 for marketers. Marketing 101 for engineers. Just enough overlap that marketers understand what a 404 error means. Just enough that engineers understand conversion funnels. This is where respect lives. 4. Connect Everyone to the Customer Jose makes engineers demo the UI to customers. When they see how their work affects a real person trying to buy something, they stop optimizing for technical elegance. They optimize for customers. 5. Let Data Kill the Opinion Wars Opinion wars destroy velocity. Jose shares customer data in every planning meeting. It neutralizes the fights. Teams learn to fail fast because the data shows them what customers actually want. 6. Embed Marketers in Engineering Teams Not for one kickoff. For the entire build. Marketers see engineers debugging errors at 2am. Migrating databases without breaking anything. When you understand what it takes, you work together differently. TAKEAWAY: Companies waste six months building products customers don't want. Marketing gives instructions without context. And engineering follows them perfectly. Jose's framework works because it treats software like what it actually is. Fluid. Adaptable. Built to change. Stop building like it's construction. Start shipping like it's software.

In just 30 days, defects dropped, morale increased... And our roadmap conversations shifted from “𝘐 𝘵𝘩𝘪𝘯𝘬 𝘸𝘦 𝘴𝘩𝘰𝘶𝘭𝘥 ” to “𝘏𝘦𝘳𝘦’𝘴 𝘸𝘩𝘢𝘵 𝘸𝘦 𝘬𝘯𝘰𝘸.” Every engineering leader wants to get the most out of their team, but it’s easy to lose sight of what really drives them: feedback. I learned this the hard way. I launched a product that was all hype, but there was nothing from the users. I quickly realized: engineers need to see the impact of their work. Without feedback, it’s all guesswork and that leads to frustration. Here’s how I turned things around: 𝐒𝐡𝐚𝐫𝐞 𝐭𝐡𝐞 𝐑𝐞𝐚𝐥 𝐓𝐚𝐥𝐤: I started recording customer calls and sharing the raw moments, the “wow!” reactions and frustrations. Engineers connect with that energy way more than bullet points. 𝐒𝐮𝐩𝐩𝐨𝐫𝐭’𝐬 𝐈𝐧𝐬𝐢𝐠𝐡𝐭𝐬: Instead of just letting support tickets pile up, we held quick 5-minute debriefs each sprint to highlight recurring issues that specs missed. 𝐎𝐧-𝐂𝐚𝐥𝐥 𝐄𝐦𝐩𝐚𝐭𝐡𝐲: Every quarter, we had an engineer join the on-call rotation. Waking up at 3 AM to fix a bug you wrote? That’s a whole new level of ownership. 𝐈𝐧𝐯𝐨𝐥𝐯𝐞 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐬 𝐄𝐚𝐫𝐥𝐲: Before features hit Jira, we brought engineers into discovery calls. Hearing the “why” from customers helped them think critically before the code was even written. The results? 30 days later, defects dropped, morale improved, and our roadmap shifted from gut feeling guesses to data driven decisions. Feedback loops are the key to growth. Start today.

Here’s how we stay on top of feature requests and bug reports from 1000+ customers as an engineering team of 6: Normally, this would be a massive effort for a product team to collect, sort, summarize, process, and communicate what these customers are telling us. But for us, this hasn’t been a problem at all. Our developers own product. When developers truly own the product, everything changes. Here’s what ownership looks like for us: 1/ Devs hopping on customer calls to deeply understand their challenges 2/ Teams breaking down silos to collaborate across engineering, sales, DX, and marketing 3/ Shipping fast. Not because of deadlines, but because they care about the outcome A great example? One of our developers owns a feature end-to-end that supports meeting bots in breakout rooms. When a customer urgently needed this functionality, he didn’t just build it. He got it live in record time, joined follow-up to ensure it worked, and took pride in solving a real problem. This approach didn’t just deliver a feature. It built trust with the customer and strengthened collaboration across our team. When teams embrace ownership, speed happens naturally because everyone cares deeply about the outcome. What’s one thing you’ve done to give your team true ownership?

Everyone in our company does support; and it's probably the one thing I will fight the hardest to preserve no matter our size or scale. Many people think that doing support is a different activity from building the product – but it’s actually one and the same. Simply put, customers pay for everyone’s salaries. Without customers, your company probably won’t exist for long. Conversely, if you have customers who love your product, the more likely you’ll succeed. Therefore, everyone’s jobs literally are in service of building a product your customers love – and the closer you are to your customers, the easier it is to achieve that. So, everyone should to talk to customers. How do you make it happen without causing mayhem? Three things that work consistently: 🤝 Executive sponsorship. In our case, that’s admittedly easy – it’s literally all Matt and I care about. But you’ll typically find most customer-focused founders and CEOs are very aligned with the idea that everyone should be speaking to customers. 🎯 Incorporate it into onboarding. Get new starters to join a customer call the very first day, then have them do product support in their first week. It may sound counterintuitive, but this beats any number of onboarding guides. I've seen it actually _accelerate_ onboarding: Hearing a customer raise a bug or ask for a feature suddenly gives everything else meaning. It teaches you about the product and how people use it immediately. You’re no longer setting up your development environment because that’s what one does, you’re setting up your development environment so you can ship a bugfix. 📆 Develop a rota. In our case, we’ve set a clear expectation that any engineer, designer or team member who’s on support any given week is not expected to also do their “day job”. Their day job that week is support. This allows everyone to stay close to customers, while also giving everyone the time and space they need to get their head down on Critically, having everyone talk to customers isn’t mutually exclusive with having an incredible support team. In fact, the larger you get, the more it becomes a requirement: Great support teams are incredible coaches to the rest of the company in talking to customers – in the same way an engineer has made a career of building, support specialists have made a career of understanding, triaging, troubleshooting, coordinating, de-escalating and resolving. Stronger together 🤝

Hard Truth: If you’re spending more on engineering than understanding your customer, you’re increasing the cost of being wrong. Counterintuitive insight from an MIT backed study I keep coming back to that Brian Bernstein shared with me: "Hardware teams that spent more effort understanding customers than engineering (marketing : engineering ratio > 1) were wildly successful. Teams that spent $1 learning for every $10 building were abject failures." Customer understanding need to be treated as a first class engineering input. Every hour you build before you truly understand: - who has the urgent problem - why it matters now - and what outcome they’ll pay for ... you are increasing the cost of being wrong. A quick check: - Do you spend more time talking to buyers/users than building? - Can you describe the problem in their words, not your features? - Do you have proof beyond “that’s cool” - like a pre order list, LOI, or pilot? If you want it, I’ll share a validation tool that helps to see where you are (problem clarity, buyer, proof, channel, whole product gaps). Comment "proof" and I’ll send it.

Organizing Teams in the Real World Organizing dev teams isn’t just about dividing headcount by the optimal Scrum team size. It’s about creating structures and interactions that minimize inefficiencies and maximize throughput. Imagine you’ve got 40 engineers (front-end, back-end, security, DevOps, BAs, etc.). Some are seasoned; others are less experienced. With limited specialists, equal skill distribution isn’t possible. So how do you balance customer focus, reduce handoffs, and optimize delivery? Approach 1: Functional Teams w/ Centralized Specialists Functional teams are organized by skill. F/E devs in one team. B/E in another. Centralized specialists support everyone. Ex: Five functional teams and a central pool of 3 security engineers and 2 DevOps experts. Pros: Deep expertise within domains. Efficient use of scarce specialists. Cons: Lots of handoffs and delays as features move between teams. Specialists become bottlenecks. Low throughput due to coordination overhead. Result: Prioritizes expertise but sacrifices efficiency and speed. Approach 2: Component Teams w/ Platform Support Component teams own specific architectural layers (e.g., database, APIs), supported by a platform team that builds reusable tools. Ex: Four component teams and a 5-person platform team for shared services. Pros: Clear ownership of systems. Standardized tools reduce redundant work. Cons: Features spanning components require coordination. Platform dependencies can delay delivery. Teams may lose focus on customer outcomes. Result: Improved scalability, but handoffs and misaligned priorities persist. Approach 3: Hybrid Cross-Functional Teams w/ Specialist Support Feature teams are organized around end-to-end business domains, supported by floating specialists or a platform team for niche needs. Ex: Six cross-functional teams, 3 floating specialists, and a 2-person platform team. Pros: Low handoffs. Teams handle most work independently. Customer-centric focus. Efficient specialist use through targeted support. Cons: Demand spikes can stretch specialists. Upskilling generalists requires investment. Result: Balances autonomy, specialization, and throughput. Best Fit: Hybrid The hybrid cross-functional model provides the best balance of autonomy, scalability, and efficiency. This topology reduces handoffs and mitigates skill shortages. Implementing the Hybrid Model 1) Organize teams around business domains (e.g., onboarding, reporting). 2) Use floating experts or a platform team for shared needs (e.g. security, DevOps). 3) Upskill generalists to reduce dependence on specialists for routine tasks. 4) Standardize tools and create reusable solutions to streamline dependencies. Reality Perfectly balanced teams are a rarity. The hybrid model delivers a practical compromise. By minimizing handoffs, focusing on customer outcomes, and optimizing the use of specialists, you can enjoy faster delivery and greater agility despite real-world constraints.