2023-05-05

Maintaining Technical Skills as a Non-Hands-On Engineering Manager

One of the biggest challenges when transitioning into engineering management is figuring out how to stay technically relevant when you're no longer spending your days immersed in code. Your calendar fills up with 1:1s, strategy meetings, and cross-functional alignment efforts. Yet, even if you're not coding daily, maintaining a strong technical understanding is absolutely crucial. It's essential for maintaining credibility with your team, making informed technical and strategic decisions, effectively coaching engineers, and identifying potential risks or opportunities. Letting your technical skills atrophy isn't an option if you want to be an effective engineering leader. Here’s how I approach staying technically sharp:

1. Redefine Your Technical Role: Beyond Daily Coding

First, I had to accept that "being technical" as a manager looks different than it did as an individual contributor (IC). My value isn't derived from being the best coder on the team anymore. Instead, it comes from:

  • Understanding System Architecture: Seeing the bigger picture, how services interact, data flows, and potential bottlenecks or failure points.
  • Evaluating Technical Trade-offs: Understanding the implications (performance, scalability, maintainability, cost) of different technical approaches.
  • Guiding Technical Strategy: Ensuring technical decisions align with broader business goals and long-term vision.
  • Asking the Right Questions: Probing assumptions during design reviews or technical discussions to ensure rigor.
  • Technical Mentorship: Guiding engineers on principles, patterns, and career growth, even if not on specific syntax.

2. Dive Deep into Code Reviews (Strategically)

While I don't review every line of code, I make time to engage thoughtfully in code reviews for significant features, architectural changes, or areas I want to understand better.

  • Focus on the 'Why' and 'How': I look beyond syntax to understand the design choices, potential edge cases, test coverage, and adherence to patterns. I ask questions like, "What alternatives did you consider here?" or "How does this handle X scenario?"
  • Look for Patterns and Anti-patterns: Reviews are a great way to spot recurring issues or ensure consistency across the codebase.
  • Allocate Time: I block out specific time for reviews rather than trying to squeeze them in between meetings. This allows for deeper engagement.

3. Actively Participate in Design and Architecture

This is perhaps the most critical area for managerial technical input.

  • Be Present and Engaged: I actively participate in technical design meetings, whiteboard sessions, and architecture reviews.
  • Ask Probing Questions: My role is often to ensure we've considered non-functional requirements (scalability, security, reliability, observability), edge cases, and alignment with overall strategy. "How will this scale?" "What are the failure modes?" "How does this fit with our monitoring strategy?"
  • Facilitate, Don't Dictate: I guide the discussion and ensure sound principles are followed, but trust the engineers doing the work to own the detailed solution.

4. Read Code Selectively and Follow Trends

Staying current requires continuous learning, adapted to a manager's schedule.

  • Selective Code Browse: Occasionally, I'll spend time reading through critical sections of our codebase, especially new services or foundational libraries, just to maintain familiarity with the structure and patterns.
  • Curated Learning: I follow key tech blogs, newsletters (like TLDR, Hacker News), relevant podcasts, and thought leaders in our specific technology domains. I prioritize learning about trends impacting our stack and industry.
  • Attend Conferences/Meetups (Virtually or In-Person): These are great for high-level overviews of emerging technologies and best practices.

5. Leverage Your Team: Learn from the Experts

Your engineers are your best resource for staying current on the specifics.

  • Ask Questions: I create an environment where it's safe and encouraged for engineers to explain technical concepts to me. "Can you walk me through how this new framework operates?" or "Help me understand the trade-offs you made here."
  • Encourage Tech Talks/Demos: Internal knowledge sharing sessions are invaluable for everyone, including managers.
  • Trust Their Expertise: Acknowledge that your senior engineers likely have deeper knowledge in specific areas than you do now. Leverage that.

6. Strategic Hands-On: Pet Projects and Spikes

While I don't contribute to production code daily, occasional, focused hands-on work helps keep skills from rusting completely.

  • Personal Projects: Maintaining a small side project using relevant technologies can be a low-pressure way to experiment and learn.
  • Occasional Spikes/Prototypes: If exploring a completely new technology, sometimes participating briefly in an initial spike can provide valuable context (ensuring I don't become a bottleneck).
  • Pairing on Tough Problems: Occasionally pairing with an engineer on a particularly tricky bug can offer deep insights into the system's state (again, used judiciously).

7. Focus on Systems Thinking and Mentorship

  • Systems View: I prioritize understanding how all the pieces fit together – the end-to-end system behaviour, dependencies, and data flows. This high-level view is crucial for strategic decisions.
  • Teaching Solidifies Understanding: Mentoring junior engineers or explaining technical concepts to non-technical peers (like Product Managers) forces me to articulate and reinforce my own understanding.

Avoid the Common Traps

  • Don't Try to Be the Hero Coder: Your value isn't in writing code faster than your team.
  • Avoid Technical Micromanagement: Trust your team on implementation details unless there's a clear red flag.
  • Resist Complete Detachment: Don't let yourself become so far removed that you can no longer understand or contribute to technical discussions meaningfully.
  • Don't Spread Yourself Too Thin: Focus your learning on technologies and concepts most relevant to your team's work and strategic direction.

Conclusion: Staying Sharp, Leading Effectively

Maintaining technical skills as a non-hands-on manager is an ongoing commitment, not a destination. It requires consciously shifting how you engage technically – moving from implementation details to architectural understanding, strategic implications, and empowering your team. By actively participating in reviews and design, leveraging your team's expertise, staying curious about industry trends, and occasionally getting your hands dirty strategically, you can absolutely maintain the technical credibility and insight needed to lead your engineering teams effectively. It's not about knowing everything; it's about knowing enough to ask the right questions, guide the right decisions, and foster an environment of technical excellence.