Dustin Boston

I care about different things now that I have grown into a lead engineer. There are some things that I have started to care more about, and some things that I have started to care less about.

What a lead cares less about

1. Personal Commit Volume
   • Junior/Senior View: “I need to ship a lot of code to prove my value.”
   • Lead View: “I need to unblock others so they can ship code.”
     • As a lead, you spend time on code reviews, design, answering questions, and clearing the path. As a result, the number of commits you make decreases.
2. The Latest and Greatest Software
   • Junior/Senior View: “Let’s use this new beta framework; it’s faster, cooler, and more modern.”
   • Lead View: “Can we hire for this? Is it stable? Does it have good documentation?”
     • Leads focus on long-term maintainability and hiring over cutting-edge trends. As a lead, I shy away from big rewrites if they are not critical.
3. Micro-Optimization & “Perfect” Code
   • Junior/Senior View: “This function can be 5 ms faster if I rewrite it three times.”
   • Lead View: “Is it good enough to ship today?”
     • Seniors often chase architectural purity. Leads are more open to taking on technical debt if it gives a business edge, like meeting a deadline. They need a plan to pay it off later.
4. How the Team Solves the Problem (Implementation Details)
   • Junior/Senior View: “This is exactly how I would write this class.”
   • Lead View: “Does the interface match the spec? Does it pass tests? Then do it your way.”
     • Leads learn to delegate ownership. Nitpicking every line of a Senior’s code to match their style creates a bottleneck. It also demoralizes the team. They care about the contract (inputs/outputs), not the implementation.
5. Being the “Smartest in the Room”
   • Junior/Senior View: “I need to have the answer to every technical question to show authority.”
   • Lead View: “I need to find the person who has the answer.”
     • A Lead’s value comes from synthesis and decision-making, not encyclopedic knowledge. They feel at ease saying, “I don’t know, let’s ask the database expert.” This change means they now route knowledge instead of sharing it.
6. Rigidity in Process
   • Junior/Senior View: “The ticket had incorrect formatting, so I won’t do it.”
   • Lead View: “This is urgent; I’ll fix the ticket later.”
     • While Leads usually enforce process, they also know when to break it. They focus less on sticking to strict rules, like needing 100% test coverage for a prototype. Instead, they focus on the practical needs of the business.

What a lead cares more about

Lead engineers change their focus from output, like writing code, to outcomes. This includes system reliability, team speed, and business value. Their focus is on the big picture. They focus on the product’s technical success. Their concerns are strategic, not tactical.

1. The “Bus Factor” (Risk Mitigation)
   • The Concern: “If we lose someone tomorrow, does the project die?”
   • The Action: Leads obsess over knowledge silos. They push for rotating key tasks. They need documentation for complex systems. They also avoid obscure technologies that are hard to hire for.
2. Force Multiplication (Developer Experience)
   • The Concern: “Why does it take 45 minutes to deploy a one-line change?”
   • The Action: Leads care about the feedback loop. They invest time in CI/CD pipelines, local dev environments, and linting tools. If they save 5 minutes for 10 developers, that’s 50 minutes of extra productivity per build.
3. Observability & Average Recovery Time
   • The Concern: “How do we know it’s broken before the customers tweet about it?”
   • The Action: Seniors care that the code passes tests; Leads care that the code emits logs. They focus on metrics, dashboards, and alerting. This way, when issues arise, they can find the root cause in minutes, not days.
4. Technical Debt as a Financial Instrument
   • The Concern: “Are we paying too much ‘interest’ on this legacy code?”
   • The Action: Leads don’t aim for zero technical debt; they aim for managed debt. They talk with product managers to “buy” time for refactoring. They explain the cost of inaction. For example, they say, “If we don’t fix this now, feature X will take twice as long to build next month.”
5. Alignment with Business Goals
   • The Concern: “We are building a Ferrari, but the business needs a moving van.”
   • The Action: Leads are the filter between “cool tech” and “profitable tech.” They prevent over-engineering. If a basic CRUD app can solve the business problem, they will block the team from building a complex microservices architecture. Even if the team wants to do so.
6. Consensus and “Disagree and Commit”
   • The Concern: “Is the team paralyzed by debate?”
   • The Action: Leads care about decision velocity. They lead technical talks and make sure everyone’s voice gets heard. They also finalize decisions to resolve ties, helping the team move forward.

The transition from Senior to Lead is fundamentally about trading personal output for team output. It requires letting go of the immediate satisfaction of closing tickets to focus on the often invisible work that keeps the system healthy and the team moving. By prioritizing business alignment, risk mitigation, and developer experience over technical perfection and personal commit counts, a Lead Engineer ensures that the team doesn’t just ship code, but delivers sustainable value.