LinkedIn Post Ideas for Heads of Engineering

We used to have a release calendar — Tuesdays and Thursdays, change advisory review, a 24-hour freeze window before each. It existed because two years ago a Friday deploy took down billing for six hours and everyone got scared. I deleted the calendar four months ago. Deploy frequency went from roughly 1.8 times a week per team to an average of 4.3 times a day across the org. What the calendar was actually protecting against wasn't deploy risk — it was our lack of confidence in rollback and observability. So before deleting it, we fixed the actual problem: automated canary rollout on every service, a rollback that takes under 90 seconds, and a paging threshold tuned so an engineer knows within 3 minutes if a deploy is degrading anything. Once rollback was fast and detection was fast, the calendar was pure overhead — a batching mechanism that turned small, low-risk changes into large, high-risk bundles because everyone crammed their work into the two allowed windows. Incident rate since deleting it: down 18%, not up. Smaller deploys, isolated blast radius, faster detection. The calendar felt like safety. It was actually concentrating risk into fewer, bigger moments. If your org still batches deploys into a calendar, the real question isn't "when do we deploy" — it's "why don't we trust rollback yet."

I still write code two hours a week. Not glue scripts, not internal tools — I take a real ticket from the backlog, same as anyone on the team. Never the critical path. Never something with a customer-facing deadline. This week it was a flaky integration test that had been quietly ignored for three sprints. Why I keep doing this at director level, honestly: it's the fastest way I have to stay calibrated on what "one story point" actually costs in our current codebase. I sat in enough planning meetings estimating work I hadn't touched in two years, and my gut was wrong by 2-3x on complexity more than once. Coding two hours a week fixed that within a quarter. It also keeps me honest about our tooling. I hit our CI wait time personally — 11 minutes for a trivial change — and that annoyance is what got CI infrastructure funded last quarter, not a survey result. What it costs me: two hours I don't have for 1:1s or planning, and I've had to be disciplined that this never becomes "the director's PR is blocking the release," because that undermines the whole point. The debate is usually framed as should-eng-leaders-code, full stop. My answer is narrower: code enough to stay honest about cost and pain, never enough to become a dependency. Where do you land on this?

Most postmortems I attended earlier in my career were compliance theater. People read a timeline off a doc, nobody disagreed, everyone left with three action items that died in the backlog within a month. Here's what changed in ours, and attendance went from mandatory-and-resented to genuinely well-attended. Facilitation moves: a postmortem is never facilitated by the engineer who caused the incident. We rotate a neutral facilitator whose only job is asking "what did the system let happen" — never "who did this." The question bank we actually use: "what information would have caught this sooner," "what almost caught this and didn't get trusted," "what's the cheapest guardrail that prevents the entire class of this bug, not just this instance." That third question is where the real value lives — it moves past the specific incident into systemic fixes. Action items: every item gets an owner and a review date inside the next sprint planning, not a vague backlog ticket. We track a simple metric — percentage of postmortem action items closed within 30 days. That number was 34% two years ago. It's 81% now, because visibility to my boss on that number made "closed within 30 days" a real incentive, not a suggestion. The cultural shift that mattered most: the most senior engineer in the room speaks last, always. Otherwise the postmortem becomes their theory of the incident with everyone else nodding. What's the one facilitation rule that fixed your postmortems?

I hired a senior engineer two years ago who interviewed better than almost anyone I'd seen — sharp system design answers, clean code in the pairing round, articulate about tradeoffs. Ninety days in, it wasn't working, and it took me another 60 days to understand why. The interview measured: can this person solve a well-scoped problem alone, under time pressure, with a clear rubric. She was excellent at exactly that. The job required: navigating ambiguous priorities across three teams with conflicting goals, and getting alignment without a clear authority to force it. Nobody had tested that, because our loop had no scenario for "the requirements are genuinely unclear and two stakeholders disagree — what do you do." The signal gap cost us close to five months of underperformance before we course-corrected her into a more scoped, single-team role, where she's since become one of our strongest performers. What we changed in the loop: a new round, unscripted, where the interviewer deliberately gives conflicting requirements from "two stakeholders" and watches how the candidate handles the ambiguity — do they ask clarifying questions, do they make an assumption and flag it, do they freeze. The uncomfortable lesson: a hiring miss is rarely about talent. It's almost always about testing the wrong axis of the job. She was never a bad engineer. We asked her the wrong questions.

We ran a structured developer experience survey every quarter for a year — not an engagement survey, a DevEx-specific one: build times, review turnaround, tooling friction, cognitive load per task. The result that changed our roadmap surprised me. I expected tooling choice — IDE, language, framework debates — to dominate the complaints. It barely registered. The number one theme, appearing in 68% of free-text responses: CI wait time. Not the existence of CI, the wait. Median wait to first feedback was 14 minutes. Engineers reported context-switching to something else during that wait and losing 20-30 minutes getting back into flow state, every time. We'd been planning to invest that quarter's infra budget in developer tooling upgrades — better linters, an IDE plugin initiative. Instead we redirected it entirely into CI parallelization and caching. Three months later: median CI wait dropped from 14 minutes to under 4. The next DevEx survey showed CI complaints down from 68% to 22%, and self-reported flow-state interruptions dropped correspondingly. The lesson: I would have bet real money on the wrong roadmap item without the survey data. Tooling debates are loud in Slack. CI wait time is silent — nobody complains about it directly, they just quietly context-switch and lose an hour a day. If you're not measuring DevEx quarterly, you're roadmapping off whichever complaint was loudest in Slack that week, which is rarely the real cost center.

We tried a dedicated "tech debt week" twice a year for two years. It failed both times, the same way. The pattern: two weeks before tech debt week, a launch would slip, or an exec would ask for one more thing before the deadline, and tech debt week would get cannibalized into a feature crunch. It happened four times out of four scheduled instances. Not once did we protect it. What we do now instead: a standing 20% capacity allocation, every sprint, no exceptions, tracked the same way feature work is tracked — in the sprint board, with story points, reviewed in retro. The difference that made it survive planning pressure: it's not a separate calendar event that competes with a launch date. It's baked into the capacity math before any commitment is made. When a PM asks for 100% of a team's sprint, the answer is structurally "you get 80%," not a negotiation that tech debt loses every time because it has no launch date defending it. Twelve months in: we've closed 340 tech debt tickets, our incident rate tied to legacy code paths is down 27%, and — the part that convinced skeptical PMs — feature velocity didn't drop. It's up slightly, because less time goes into working around debt we used to just live with. Dedicated weeks compete with deadlines and lose. A standing percentage is structural, and structure survives pressure that intentions don't.

Six months of AI coding assistants across my org, and here's what actually changed, not the hype version. Review load shifted, didn't shrink. PR volume per engineer is up roughly 30%, but review time per PR is up too — reviewers report AI-generated code reads confidently correct even when it isn't, so they've had to slow down and verify assumptions more carefully than with human-written code they could ballpark-trust from a known author. Juniors ramped differently. Two juniors hired this cycle ramped faster on syntax and boilerplate but slower on debugging instinct — when the assistant's suggestion was subtly wrong, they had less muscle memory for spotting it than juniors from two years ago who'd had to write more of that code by hand. Certain bug classes grew. We've seen a rise in subtly incorrect error handling — code that looks like it handles an edge case but doesn't, because the assistant pattern-matched a common shape without reasoning about our specific failure modes. What held steady: architecture decisions, incident response, and cross-team negotiation are untouched. The assistant writes functions. It doesn't decide which service should own a piece of state. Net assessment: real productivity gain on volume, real new tax on review rigor and junior debugging development. Not the "10x engineer" story, not the "AI is useless" story either. What's your six-month read, honestly?

The two slides that finally made engineering velocity legible to a board that only wanted to hear about features. Slide one: a simple two-line chart. Line one is feature throughput. Line two is production incidents per month. I show the correlation — the quarter we cut infrastructure investment to ship faster, incidents rose 40% and the following quarter's feature throughput actually dropped, because the team spent it firefighting instead of building. Slide two: a capacity allocation pie chart translated into board language — not "20% tech debt, 80% features" but "this percentage of the team's time is protecting the revenue you already have, this percentage is building the revenue you're asking for next." What changed in the room: before these slides, every velocity conversation was engineering asking for trust. After, it was a board looking at a chart connecting infrastructure investment directly to feature output, in the unit they already track — revenue risk and revenue growth, not story points or sprint velocity. I stopped bringing sprint burndown charts to the board entirely. Directors don't care about our process; they care whether the process protects and grows the business. Board communication is the single skill gap I see stall engineering leaders' careers the most. Not technical judgment — the ability to translate technical judgment into the two numbers a non-technical director already trusts.

Five signs your engineering org has a planning problem, not a talent problem — patterns I've had to defend to executives more than once. 1. Deadlines miss by a consistent percentage, not randomly. If every project runs 30-40% over, that's a systemic estimation or scoping bias, not five separate teams full of unreliable engineers. 2. Thrash from mid-sprint priority changes. I tracked this for a quarter: teams that had their sprint priorities changed more than once mid-cycle missed deadlines at triple the rate of teams left alone, regardless of who was on them. 3. Hidden dependencies surface late. If "we didn't know team B needed to ship first" comes up repeatedly, that's a planning visibility gap, not an execution failure. 4. Optimistic estimates compound across a dependency chain. Three teams each estimating "probably fine" on their piece of a joint launch reliably produces a launch that's very much not fine, because the uncertainty multiplies instead of averaging out. 5. The same few engineers get pulled into every fire. If your best people are perpetually firefighting instead of building, that's a resourcing and prioritization failure upstream of anything they're doing wrong. I use this list specifically when an exec suggests we need "better engineers." Sometimes that's true. Far more often, the org needs better planning discipline, and no amount of talent survives a planning process that sets everyone up to miss.

What's the best engineering culture decision you inherited from someone else — not one you get to take credit for? Mine: my predecessor instituted a rule that no engineer touches production configuration without a second engineer reviewing the exact command, not just the PR — a live, synchronous check before execution. I thought it looked like bureaucratic overkill when I inherited it. I nearly cut it in my first quarter to speed up on-call response. I didn't cut it. Eight months later it caught a config change that would have wiped a production cache during peak traffic — the reviewing engineer caught a typo'd environment flag thirty seconds before execution. I've kept it, extended it to two more high-risk systems, and I make a point of crediting the person who built it every time someone new asks why we do this. It would have been easy to quietly claim it as my own practice by now. I don't, because the actual lesson is bigger than the rule: good practices built under different pressure than the ones you're currently facing are easy to underrate. What's the practice you inherited, almost cut, and are glad you didn't?