How Engineers Drive System-Level Improvements

Rethinking Requirements in Hardware Engineering Requirements management isn’t just about checklists—it’s the difference between effective collaboration and costly missteps. Here are once-unconventional approaches to requirements now embraced by top teams 1. From “Requirements” to “Design Criteria” Early systems engineers were part engineer, part lawyer. Someone had to create “techno-legal documents” to manage external contracts. These evolved into requirements. Many cultural issues stem from using requirements incorrectly–as a weapon rather than tool for collaboration. Not all requirements need to be treated as commandments. Reframing lower-level requirements as design criteria reduces resistance among engineers, empowering them to see requirements as flexible guidelines open to questioning and adjustment. This is what you want to inspire. 2. Culture of Ownership and Accountability Drives Agility A strong requirements culture is built when engineers “own” their work. Engineers must take responsibility for the requirements they design against, creating a culture of ownership, responsibility, and systems-mindedness. Assigning a clear, single-point owner for each requirement, even across domains, encourages each engineer to think critically about their area’s requirements, establishing ownership and trust in the process. Encouraging information flow between teams helps engineers see how their work impacts others, leads to reduced and stronger system integration. Requirements should be viewed as evolving assets, not static documents. You want engineers to push back on requirements and eliminate unnecessary systems rather than add more requirements, complexity, or systems. 3. Requirements as Conversations, Not Just Checklists Requirements aren’t just specs or checklists—they’re starting points for cross-functional discussions. Every problem is a systems problem, and to solve complex challenges, engineers must be systems thinkers first and domain experts second. In traditional settings, requirements stay isolated in documents. But when teams understand why requirements exist, where they come from, and who owns them—and engage in continuous dialogue—they blur the lines between domains and foster a systems-oriented mindset. This collaborative environment accelerates problem-solving, enabling engineers to align quickly and tackle challenges together. Instead of siloed requirements for each subsystem, drawing dotted lines and encouraging information flow between teams helps engineers understand how their work affects others. This cross-functional awareness leads to fewer misalignments and stronger system integration. When you see engineers make sacrifices in their own area to benefit the overall system, you know you are on the right track. There you have it. The full guide goes into specifics on how to start implementing these ideas in tools.

When Systems Fail: Fixing Processes, Not Just Bugs At Amazon, we're deeply committed to moving fast. But true velocity isn't just about coding quickly—it's about building systems that allow us to move swiftly without compromising quality. This requires learning from every mistake and fixing root causes, not just symptoms. Here's a recent example from my work: Our automated scanners flagged several potential issues across our codebase. An engineer quickly fixed a few instances, and the immediate alerts were resolved. Success, right? Not quite. Looking deeper, I noticed these issues were in code that hadn't been used for some time. Our scanners were being "too thorough"—flagging issues in code that was essentially dead weight. Instead of celebrating the quick fix, I chose to address the underlying process problem. I wrote simple tooling to conduct a comprehensive scan of our codebase. With hundreds of engineers working for many years, we had accumulated a significant amount of unused code. This unused code didn't directly affect customers, but it created several hidden costs: - Engineers spent time investigating non-issues - Attention was diverted from real customer problems - Cognitive load increased when maintaining the system - New team members struggled to understand what was actually important With a concerted effort across the organization, we identified and safely deprecated substantial portions of unused code. This not only eliminated false positives from our scanners but also simplified our systems and allowed engineers to focus on what truly matters. The lessons here extend beyond this specific example: 1. When fixing bugs, always ask: "Is this a symptom of a broader process issue?" 2. Look for patterns across individual incidents 3. Build tools to systematically identify and address root causes 4. Consider the hidden costs of complexity in your systems 5. Connect every process improvement back to customer impact Moving fast in the long term requires pausing occasionally to fix your foundations. Every bug is an opportunity not just to patch a hole, but to strengthen your entire system. What process improvements have you made after encountering recurring bugs? How do you balance quick fixes with systematic improvements? *I'm sharing practical lessons from my experience as a Senior Principal Technologist at Amazon. Follow me for more posts on using GenAI in technical practice, leading technical teams, making data-driven decisions, and building better systems.*

Why High-Impact Engineers Challenge Ideas And How to Do It Right In fast-moving teams, engineers often feel the pressure to deliver quickly—to say “yes” to every requirement and build exactly what’s asked. And while it is critical, a product’s long-term success doesn’t just depend on how fast we build—it depends on whether we’re building the right things, the right way. Engineers uniquely prioritize scalability, maintainability, performance, and stability. While business/product teams focus on customers and revenue, and design teams on UX, engineers understand technical decisions' long-term impact. And that’s why it’s our responsibility to contribute to product decisions—not just execute them. A system doesn’t slow down or break overnight—it happens gradually, with every workaround, quick fix, or rushed feature that wasn’t thought through from a scalability perspective. When engineers don’t raise concerns early, we may end up building things that work today but create massive bottlenecks in the future. Here’s a familiar scenario: 1️⃣ A new feature request comes in with tight deadlines. 2️⃣ It’s implemented exactly as asked to meet the timeline. 3️⃣ A few months later, scaling issues arise, requiring major rework and downtime. What if we took a step back earlier and had a collaborative discussion about trade-offs? 🚀 What’s the simplest way to achieve this goal without introducing complexity? 🚀 Does this feature align with our long-term architecture? 🚀 Can we ensure this scales before we commit to a quick implementation? When engineers start asking these questions proactively, they become more than just problem-solvers—they become decision-makers. 💡 Influence Product & Business Teams Without Being a Roadblock Challenging an idea isn’t about saying “No”—it’s about shaping a better “Yes.” A common mistake engineers make when raising concerns is focusing on why something won’t work instead of how to make it work better. Instead of saying: ❌ “This is impossible to build.” ✅ Say: "This approach may cause performance issues at scale. Would you be open to exploring an alternative that achieves the same goal but is easier to maintain?" Instead of saying: ❌ “This feature request doesn’t make sense.” ✅ Say: "To clarify, what’s the key outcome we’re trying to achieve? If the goal is X, we might be able to achieve it in a more efficient way." Instead of saying: ❌ “This timeline is unrealistic.” ✅ Say: "We can prioritize delivering the core functionality within this timeframe, and if needed, we can plan the additional parts in the next phase. Would that work?" The best way to grow in your career isn’t just by getting better at coding—it’s by becoming a partner in product development. Next time you’re given a requirement, ask yourself: 💡 “Am I just building this, or am I shaping how it should be built?” Because the best engineers don’t just deliver code. They deliver impact. 🚀

How I made my engineering team 10x more productive, without hiring a single person. I just started beating the drum. Not of velocity. Not of deadlines. But of clarity. Every day, I told the story of what mattered: Who the customer was. What problem we were solving. Why it mattered now. I repeated it in standups, roadmap reviews, code reviews, and 1:1s. I made the vision visible until the team could repeat it without me. And then something changed. Engineers stopped waiting for perfect specs. They started asking better questions. They scoped more intentionally. They stopped building “just in case” solutions and started delivering exactly what was needed. We didn’t change the process. We didn’t add new tools. We just made clarity the norm. The result? Fewer delays. Smarter trade-offs. Less rework. Faster progress. And a team that wasn’t just moving faster, but building what mattered. You don’t need more people to scale. You need more clarity. Especially for engineers. Because when the goal is fuzzy, even the best teams slow down. But when clarity is built into the culture, the whole system speeds up. How do you make clarity unavoidable inside your team?

I’ve spent nearly a decade mentoring, guiding, and managing engineers And whenever someone asks me: “How do I grow to the next level?” Most people expect answers like: → System design → Code quality and other factors Those are hygiene. The real shift happens in how you choose to create impact. And over the years, I’ve seen two clear types of growth paths: 1. Incremental Engineers They’re reliable. They’re consistent. They keep the system afloat when no one else is looking. They reduce tech debt quietly. They make alerts go from noisy to signal-rich. They take a flaky test case and make it production-ready. This has quiet impact, but it builds over time. You get Compound credibility with this type of working style. You trust them with anything because they’ve earned it, over 100 small wins, not one loud one. 2. Transformational Engineers These folks move like product managers with a deep tech context. They see the bottleneck, and instead of working around it, they rewire the system. They introduce a new infra layer. They sunset a decade-old tool. They change how an entire team ships software. Their strength is Conviction + velocity. They’re not afraid to take bets. They know when to ship fast, when to pause, and how to bring people along. But you don’t have to be just one. The best engineers I’ve worked with knew when to go heads-down and when to go head-first. → When to say “I’ll fix it” → And when to say “Let’s rethink it” But if you’re always fixing bugs, adding logs, and cleaning old scripts, you're growing sideways. And if you're always chasing big changes without owning the maintenance, you're risking team trust. Real engineering growth comes from mastering both mindsets. → Incremental for stability. → Transformational for velocity. And the judgment to know when to switch. That’s what takes you from respected to irreplaceable.

Engineers aren't babies. Give them the time and they'll improve their own productivity. All this focus on improving the experience and productivity FOR engineers... they have some responsibility here too. Platform teams are important, but they're not a complete solution. Platform teams will only tackle the problems faced by the majority of engineers/teams. What about all the problems that only affect a subset of teams? Platform teams are busy, the reality is they will never get around to addressing the "smaller" problems. Nor should they. Engineers are more than capable of solving things for themselves. Think about platform teams as a top-down approach to improving DevEx, giving engineers time to improve things for themselves as a bottom-up. If you want meaningful improvements to experience and productivity, you need both top-down and bottom-up. An example close to home - Engineering teams at Atlassian use 10% of their time to improve things for themselves. This is separate from the efforts of platform and experience teams. You don't need to give engineers 10% time (although it does work well), but you should have some strategy for empowering engineers to improve their own productivity. #DeveloperExperience #DevOps #PlatformEngineering

Engineering teams waste *a lot* of time delaying improvement. I've seen organizations delay improving developer experience by literal years because they're waiting for: → teams to use tools in the same way in order to compare across the org (won't happen) → the "perfect" process to be defined before starting (it doesn't exist) → automated data collection from systems to be built out (when self-reported data is sufficient for decision-making) → buy-in from every single stakeholder (impossible at scale) Perfect data just doesn't exist, and progress beats perfection every time. You should work toward having data that is clean, continuous, and automated (when necessary), but don't wait for that to happen to get started. Start small, iterate continuously, and focus on making better decisions. The best improvements come from teams willing to experiment with "good enough" solutions today rather than theoretical perfection tomorrow.

Small process improvements compound into massive team wins. Here's what I've learned scaling our engineering team at Fcode Labs. Good code isn't just about writing code. It's about building systems that let teams work better together. After many years of improving, these internal processes have made a significant difference. 1. Standardized Code Reviews. Not the exciting stuff, but essential. We developed clear review checklists that caught 90% of common issues before they hit production. New engineers know exactly what to look for, seniors save time on repetitive feedback. 2. Automation Where It Matters. We are automating the boring stuff, deployment checks, test coverage reports, dependency updates. But keeping human eyes on critical decisions. Automating processes that are: • Repetitive • Rule-based • Low-risk if they fail 3. Living Documentation. Documentation isn't a one-time thing. Our documents in Confluence evolves daily: • Complying industry standards • Templates for common processes • Real examples from our projects • Regular cleanup of outdated docs The benefit we saw? These "boring" processes actually sparked more innovation. When teams spend less mental energy on routine tasks, they have more bandwidth for creative problem-solving. Here is how Manas Najmuddeen is driving the change inside the company: https://lnkd.in/gwvWd7Jh But.. No process is perfect. We're constantly tweaking based on feedback. What worked at 20 people needed adjustments at 40, and again at 80. What we've learned: Start small. Pick one process to improve. Measure the impact. Adjust. Repeat. Curious: What's one small process change that made a big difference in your engineering team? #SoftwareEngineering #TeamEfficiency #RemoteWork #Engineering #Leadership