How to give and receive technical feedback: a guide for engineering teams

Feedback is the primary mechanism for growth in engineering teams. Yet most engineers are bad at both giving and receiving it. The cost of avoiding honest feedback is slow team improvement and unresolved design problems. Building a culture of effective feedback is one of the most important things an engineering leader can do.

When giving feedback, focus on the work, not the person. Instead of "you didn't think about error handling", say "this function doesn't handle the case where the API returns a 500 should we add a try-catch?" This depersonalizes the critique and keeps the conversation constructive. The distinction between criticizing the person and criticizing the work is subtle but crucial.

Be specific about what you're seeing and why it matters. "This query runs in O(n^2) and will slow down as the dataset grows" is actionable. "This code is slow" is not. Connect the technical observation to a concrete impact that the receiver can understand and act on. Specific feedback creates a clear path to improvement.

Frame feedback as a hypothesis, not a verdict. "I'm concerned about thread safety here what happens if two requests arrive simultaneously?" opens a discussion. "This is not thread-safe" closes one. The former invites collaboration; the latter invites defensiveness. Language shapes how feedback is received.

When receiving feedback, separate understanding from agreeing. Your first job is to understand what the other person is saying. Ask clarifying questions, restate their point in your own words, and thank them before deciding whether to act on it. This pause between receiving and reacting is where growth happens.

Avoid the defensive spiral. When you feel defensive, pause and ask yourself: "Is there any truth in this feedback? What can I learn from it?" Even poorly delivered feedback often contains a useful kernel. The signal in feedback is rarely zero. Train yourself to extract value even from feedback that feels unfair.

Build a culture where feedback goes both ways. Junior engineers should feel empowered to give feedback to seniors. The best teams normalize upward feedback by having seniors explicitly ask for it. When leaders model receiving feedback well, the entire team follows.

Schedule regular feedback time rather than only giving it in code reviews. A dedicated monthly 1:1 for growth feedback creates space for the conversations that code review comments cannot address. Structured feedback prevents the accumulation of unspoken issues that damage team dynamics.

Practical Implementation

Adopt a mindset of continuous improvement. Every project, every sprint, every incident is an opportunity to learn and improve. Hold retrospectives after major milestones and incidents. Write down lessons learned and share them with your team.

Build systems that are easy to change. Good modularity, comprehensive tests, and clear documentation make change safe. The cost of change in a well-designed system should be proportional to the complexity of the change, not the size of the codebase.

Common Challenges

The biggest challenge in engineering is managing complexity. Systems naturally grow more complex over time. Fight this trend with deliberate effort: refactor aggressively, delete dead code, simplify interfaces, and document architecture decisions.

Communication overhead grows quadratically with team size. The more people involved in a decision, the longer it takes. Keep teams small (6-8 people) and give them autonomy over their domain. Use written proposals for cross-team decisions to allow asynchronous collaboration.

Real-World Application

A practical engineering practice: write a one-page design document for any change that takes more than a day. Include the problem, proposed solution, alternatives considered, and key risks. Share it with stakeholders for feedback before writing code. This simple practice prevents costly wrong turns.

Key Takeaways

Fight complexity continuously. Keep teams small. Write things down. Learn from everything. The best engineers build systems that make future changes easy.

Advanced Implementation

Implement architecture decision records for every significant technical decision. An ADR captures the context, decision, consequences, and alternatives. Over time, ADRs become the definitive history of your system's evolution. They answer the question "why did we do it this way?" that future engineers will inevitably ask.

Use RFCs (Request for Comments) for major changes. An RFC is a written proposal that is shared with the team for review before implementation begins. RFCs surface issues early, incorporate diverse perspectives, and create a shared understanding of the design. The time invested in writing an RFC is repaid many times over by avoiding wrong turns.

Knowledge Management

Build a shared team knowledge base. Common wisdom and tribal knowledge should be documented and accessible. Use a wiki, README files, or a documentation platform. Keep documentation up to date as part of the definition of done for each task.

Implement brown bag sessions where team members share knowledge on topics of interest. Weekly 30-minute sessions on any technical topic build a culture of learning and sharing. The best teams are those where everyone is both a teacher and a student.

Common Mistakes and How to Avoid Them

The most common engineering mistake is underestimating the value of simplicity. Complex solutions are harder to debug, harder to change, and harder to operate. Always ask: "What is the simplest thing that could possibly work?" The simplest solution is usually the best one, at least as a starting point.

Another frequent error is not writing things down. Tribal knowledge that is not documented becomes a bottleneck. Decisions that are not recorded cannot be revisited. Architecture that is not described cannot be understood. Write down decisions, designs, and processes.

Conclusion

Great engineering is about managing complexity, making good decisions, and building systems that are easy to change. Invest in simplicity, documentation, and testing. The best engineers are not the ones who write the most code they are the ones who build the most value with the least complexity.

Getting Started

If you are new to the engineering field, focus on building a strong foundation in the fundamentals. Learn how computers work CPU, memory, storage, networking. Learn how operating systems work processes, threads, file systems, networking stacks. Learn how programming languages work compilers, interpreters, type systems, memory management. These fundamentals rarely change, while frameworks and tools come and go.

Develop strong debugging skills early. Learn to use debuggers, profilers, and logging effectively. Learn systematic debugging techniques like binary search and hypothesis testing. Good debugging skills make you productive from day one and improve every tool you learn.

Pro Tips

Write code that is easy to delete. The best code is code that can be safely removed when requirements change. Loose coupling, clear interfaces, and comprehensive tests make code deletable. Code that is hard to delete becomes permanent technical debt that constrains future development.

Read code more than you write it. Reading production code, open-source libraries, and well-written codebases teaches patterns and practices that improve your own code. Code review is one of the best learning opportunities review your teammates' code and ask them to review yours.

Related Concepts

Understanding system design helps you build systems that work at scale. Learn about load balancing, caching, database scaling, message queues, and microservices. System design interviews test this knowledge, but more importantly, system design skills help you build better systems regardless of scale.

Understanding how to measure engineering effectiveness helps you improve your team's performance. Learn about DORA metrics (deployment frequency, lead time, mean time to recovery, change failure rate) and how to improve them. Data-driven improvement is more reliable than intuition-based improvement.

Action Plan

This week: read the codebase for one system you do not usually work on. Understand its architecture, data flow, and design decisions. Share what you learned with your team.

This month: refactor one piece of code that is hard to understand or change. Make it easier to read and modify. Add tests if the code does not have them.

This quarter: learn a new technology that is outside your comfort zone. If you are a frontend developer, build a backend service. If you are a backend developer, build a frontend component. Cross-disciplinary knowledge makes you a more versatile engineer.

-

Rizwan Saleem | https://rizwansaleem.co