It’s All Just Leadership After All  ## Metadata - Author: [[James Stanier]] - Full Title: It’s All Just Leadership After All - Category: #articles - Document Note: --- tags: - #management - #leadership - #engineering Author: James Stanier Source: Article Reference: https://www.theengineeringmanager.com/managing-managers/its-all-just-leadership-after-all/ date created: 2025-08-23 00:00 --- # Title: It’s all just leadership after all — Managing managers and senior ICs with one model ## Table of Contents: - [📚 References](#-references) - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#-notes) - [📖 References](#-references-1) - [🗣️ Paraphrase](#-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical validity](#-logical-validity) - [🎯 Conclusion](#-conclusion) ### References: - Will Larson’s Staff Engineer archetypes: https://lethain.com/staff-engineer-archetypes/ ## 📝 Summary: The article argues that senior leaders manage both managers and senior individual contributors (ICs), and that the most effective approach is the same for both: focus on developing their leadership at the intersection of their roles while maintaining accountability for targets and delegating implementation. Using a delegation spectrum, leaders should set clear outcomes, coach heavily on leadership behaviors, and leave execution details to the person’s domain—organizational for managers, technical for senior ICs. This unified model promotes alignment and collaboration. ## 📖 Main Content: The author challenges the assumption that managing senior managers and senior ICs requires distinct playbooks. In modern dual-track organizations, senior ICs (e.g., Principal/Distinguished Engineers) hold equal seniority to managers. A delegation framework clarifies how to lead both: leaders keep tight ownership of “the target” (outcomes, metrics, success criteria) and coach leadership behaviors; managers then assemble teams/processes to hit the target, while senior ICs assemble technical solutions. Examples include shipping a new feature, improving reliability (uptime, latency, error rates), or improving speed (throughput, P99, resource use). When both roles share the same target and measurement, collaboration arises naturally. Personal reflection: This “target control + delegated implementation” model reduces managerial complexity and avoids micromanagement of domain specifics. It reframes leadership as a shared competency—vision, influence, prioritization, and accountability—rather than job-title dependent. It’s particularly useful during scale when cross-role friction can occur; aligning both to identical outcomes creates joint ownership and removes zero-sum dynamics between people leadership and technical leadership. ### 🗒️ Notes - Dual-track seniority - Senior ICs can be peers to managers in scope and impact. - Examples: Principal → Director; Distinguished → VP. - Core question and answer - Q: Manage senior managers vs. senior ICs differently? - A: No—apply one unified strategy centered on leadership development. - Delegation spectrum - Delegate responsibility while maintaining accountability. - Adjust hands-on involvement based on competency/task fit. - Leadership at the intersection - Managers: lead organizations—teams, people, processes, accountability for org output. - Senior ICs: lead technical initiatives—direction, architecture, accountability for technical success. - Intersection: leadership behaviors (setting direction, influencing, prioritization, accountability). - Control the target, delegate the “how” - You own outcome, goals, and metrics. - Managers choose team/process; ICs choose technical approach. - Example targets and metrics - Ship new feature: assemble team/process vs. solution/architecture. - Reliability: uptime, latency distribution, error rates. - Performance: throughput, P99 latency, resource usage. - Collaboration corollary - Shared targets and measurements drive natural alignment between EMs and Staff+ ICs. - Managerial fundamentals emphasized - Coaching, 1:1s, feedback loops, outcome clarity, and leadership development. ## 📖 References: - Will Larson, Staff Engineer archetypes: https://lethain.com/staff-engineer-archetypes/ - Article: https://www.theengineeringmanager.com/managing-managers/its-all-just-leadership-after-all/ ## 🗣️ Paraphrase: - Original idea: “You don’t need special approaches... apply the same strategy to both... encourages the best behaviors.” - Paraphrase: Distinct management toolkits aren’t required for managers and senior ICs; a single leadership-focused method works for both and actually draws out their strongest practices. - Original idea: “What you keep within your close control is ownership of the target... the details... are an implementation detail that you delegate to them.” - Paraphrase: Retain tight control over outcomes and success measures, but hand off the execution tactics—organizational for managers, technical for ICs—so they design the path to the goal. ## 📰 Newsletter: Learning to lead without micromanaging? This week we’re spotlighting a practical model for engineering leadership: set sharp targets, coach leadership, and let experts pick the “how.” Whether you’re guiding managers or Staff+ ICs, aligning everyone on the same outcomes (think uptime, P99, or time-to-ship) drives collaboration instead of turf wars. Community highlights: - WordPress contributors continue iterating on performance tooling—great fodder for outcome-based goals. - New plugin drops worth exploring for learning web dev: query performance visualizers and LCP debuggers that make “target control” tangible. Recent updates: - Dev rel resources on outcome-driven roadmaps. - Fresh docs on sustainable OSS funding models. New plugins: - Performance metrics dashboards that surface P99 and error budgets. - Contributor onboarding helpers (issue templates, mentorship prompts). Read more on aligning managers and Staff+ ICs around the same targets and letting them select the implementation. It’s leadership all the way down—and it’s surprisingly freeing. For IC archetypes, see the widely cited overview of Staff roles by Will Larson: Staff Engineer archetypes. ## ✅ Action Items: Prompt for aligning the article to your Developer Advocate and OSPO trajectory: “Analyze how this article’s unified leadership model (own the target; delegate implementation) strengthens: - Open-source advocacy: Define outcome metrics for community health (new contributors onboarded, time-to-first-PR, review SLAs), while enabling maintainers and community ICs to design processes/technical solutions. - Contributor engagement: Use shared targets to align community managers and core maintainers; coach both on leadership behaviors (mentorship, decision records, RFCs). - Education: Translate targets into curricula (workshops on reliability metrics, performance profiling, governance practices) and measure learning impact (pre/post assessments, contributor retention). - Sustainability: Tie funding proposals to concrete outcomes (issue backlog velocity, security triage times), maintaining accountability while letting teams choose how to deliver. - OSPO direction: Operationalize “target control” via program charters, OKRs, and health dashboards; empower EMs and Staff+ ICs in the OSS ecosystem to own implementation (governance, automation, roadmaps). - Transparency and inclusivity: Publish targets, decision logs, and metrics; facilitate equal footing for managerial and technical leaders in committees; coach leadership behaviors across both tracks.” Deliverables: - Define 3–5 quarterly targets (e.g., reduce PR review time P90 to <72h; increase first-time contributor conversion by 25%). - Establish shared dashboards for EMs and Staff+ ICs. - Create leadership coaching plan applicable to both roles (feedback rubrics, 1:1 cadence). - Publish an RFC for “Unified Target Ownership in OSS Programs.” ## 🧪 Hypotheses: - H1: Team - Summary: Managing senior managers and senior individual contributors requires the same approach to leadership. Both roles require delegation of responsibility while maintaining accountability. The key is to focus on the intersection between the two roles: leadership. Managers demonstrate leadership by leading organizations, while senior individual contributors demonstrate leadership by leading technical initiatives. By developing their leadership skills and providing coaching and feedback, managers can effectively manage both roles. The manager sets the target, while the direct reports choose how to achieve it. This approach encourages collaboration and alignment between the two roles. - URL: https://www.theengineeringmanager.com/managing-managers/its-all-just-leadership-after-all/ Once upon a time, in a galaxy far, far, away, when I first got into management, I had mistakenly assumed that progression up the org chart meant only managing *other* managers. How I was totally wrong. Individual contributor career progression grows in parallel with management career progression, and in large organizations that implement these dual tracks, you will see individual contributors with the *same* seniority as managers. And this goes all the way up to the top of the org chart. For example, at large technology companies you’ll find Principal Engineers reporting to Directors and sometimes you’ll find Distinguished Engineers reporting to VPs. Each has a different skill set but the same seniority and scope. When a manager oversees a broad organization, a mix of managers and individual contributors cascade downwards from them in the org chart, with each pair typically overseeing the same subsets of the entire department. If you’re wondering what kinds of things these senior individual contributors do and how they operate, then check out Will Larson’s post on [Staff Engineer archetypes](https://staffeng.com/guides/staff-archetypes). Progression up the managerial track therefore isn’t just about managing other managers: it’s also about *managing senior individual contributors* too. This makes senior management doubly challenging, because you need to be able to manage both roles effectively, and a new senior manager may now be managing individual contributors that have *far, far* surpassed them in their own craft. The pertinent question is whether you should *manage senior managers and senior individual contributors differently*. After all, they have different roles and responsibilities, and so it would be natural to assume the way that you manage a Staff Engineer would be different than the way that you manage an Engineering Manager. Right? Nope, that assumption would also be wrong. Sorry. You *don’t* need special approaches for managing both roles. In fact, you can apply the *same* strategy to both, and not only does this simplify your approach, it actually encourages the *best* behaviors from both roles. Let’s explore this in more detail. #### Control at the Intersection Previously in my writing we have covered delegation, which is one of those core Management 101 concepts that you need to get right from the beginning. Delegation isn’t just about telling people what to do. It’s about the delegation of *responsibility* whilst maintaining *accountability*. Delegation isn’t a Boolean choice either: it is a spectrum that you traverse depending on the competency match between the task and the person or team that is doing it. You may assert *more* control through hands-on involvement or *less* control through delegation. It turns out that we can use this delegation model to work out how best to manage senior staff that report to you, regardless of whether they are a manager or an individual contributor. The key is to think about the intersection between the two roles. The Venn diagram below illustrates this: Both circles represent the roles of senior managers and senior individual contributors. The circle on the left is that of the manager (who produces output through *management*), and the circle on the right is that of the individual contributor (who produces output through *technical contribution*). The *intersection* between the two circles is the shared aspect of the two roles: *leadership*. Yes, leadership an overloaded and sometimes hand-wavy word that often means nothing. But what do we specifically mean by it? Let’s break it down: * *Managers demonstrate leadership by leading organizations*. Whether it’s one team or a whole department, they are accountable for the output of the organization that reports to them. The responsibility of individual tasks is delegated to their direct reports, and the manager leads the organization to achieve its goals through defining the right teams, people, and processes. * *Senior individual contributors demonstrate leadership by leading technical initiatives*. This may manifest in being the lead developer on a project, or being responsible for a technical area of the product. Even though they do not have direct reports, they set technical direction and are accountable for its success. The key to managing both roles with the same approach is to focus on that intersection between the two circles: *developing their leadership*. This is where you should assert the most control, and where you should be most hands-on. This is where you should be coaching them, giving them feedback, and helping them to grow. It’s where you should work closely with them to ensure they are working on the right things with the right people at the right time. What you keep within your close control is ownership of the *target* that your direct reports are aiming for, but you let them choose exactly *how* they choose to hit it. A manager reporting to you will aim at that target by constructing the right team, people, and processes for the job. Then, they’ll use their managerial skills to make it happen. Given the same target, a senior individual contributor will aim at it by assembling the right technical solution. Then, they will use their technical skills to make it happen. Example targets are: * *Building a new feature*. A manager will assemble the right team, people, and processes to build it. A senior individual contributor will assemble the right technical solution to build it. * *Improving the reliability of a system*. The responsibilities of the roles are outlined as above, but the target will be key metrics to achieve such as increasing uptime, smoothing the range of latency, and reducing error rates. * *Improving the speed of a system*. This time the target will be metrics such as increasing throughput, improving P99 latency, and a reduction in resource usage. Whether you’re managing a manager or a senior individual contributor, the aim is the same: you stay hands on and control *what* their target is. However, the details of *how* that target is achieved is an implementation detail that you delegate to them. By utilizing your management fundamentals of coaching, delegation, and 1:1s, combined with your focus on the target, you can lead both roles in the same way. The neat corollary of this is that it encourages close collaboration between the two roles by default. For example, if an Engineering Manager and their Staff Engineer are aiming at exactly the same target and being measured on its success, then collaboration and alignment follows almost effortlessly, making everyone’s job easier., It’s All Just Leadership After All, James Stanier, 01heqgpq3vwde293f87n60fyt6.