Writing about how the things that look good in the book actually work in the field.
Notes on Scrum ceremonies, team leadership and software engineering. Every post follows the same skeleton: what it is for → how it should work → how it breaks → checklist. Practice, not theory.
Scrum and Process
The ceremonies are a chain: broken refinement makes planning drag, broken planning turns the daily into a status report. That is why these are written to be read in order.
See all →Being Agile vs Doing Scrum
Agile does not end the chaos; it makes it visible. That is why teams can run every ceremony and still not be agile.
SCRUMScrum or Kanban: Not a Methodology, the Way Work Arrives
We took 9 items into the sprint and finished 4; 23 requests came from outside in the same two weeks. A decision table by how work arrives, and a rotating one-person Kanban lane.
SCRUMBacklog Refinement: Kill Bad Ideas Early
Refinement is a funnel, not a meeting. Back-of-the-envelope filtering and ROI in one shared currency.
SCRUMGrooming: Not a Ticket Reading Session
The PO's job is not to read out what will be built, but to explain why it matters.
SCRUMSprint Length: Not Two Weeks, the Speed of Feedback
Two days of work reached the user after more than nine weeks. We tried one-, two- and three-week sprints for eight sprints each: ceremony load, review attendance and feedback per month.
SCRUMSprint Planning: Commitment, Not Estimation
Good planning is boring. If surprises show up, the preparation failed. Capacity math and the pull system.
SCRUMStory Points: Not Time, Uncertainty
Asked “how many hours is one point?”, I said “five and a half”; an epic planned for 1.5 sprints took 5. Points turned into hours, inflated velocity and six sprints of #NoEstimates.
SCRUMDaily Standup: Synchronization, Not a Status Report
If what you did yesterday does not affect today, it does not matter. Walking the board, and the async option.
SCRUMSprint Goal: One Sentence, Not a Ticket List
On day eight, four person-days of work did not fit. We argued for 40 minutes and dropped the item the campaign needed. A goal is the one sentence that tells you what to drop.
SCRUMSprint Review: A Feedback Loop, Not a Demo Show
If nobody objects, nobody is listening. Silence is the worst signal.
SCRUMDefinition of Ready: A Conversation Trigger, Not a Gate
A story that was not ready ate a third of the sprint. The 14-item gate I built in response blocked the work for three sprints. A checkbox asks for a yes; a question asks for a name.
SCRUMRetrospective: Tracked Actions, Not Wishes
Definition, owner, deadline — without all three it is a wish, not an action.
SCRUMEpic, Story, Task: How to Break Work Down and the 8-Hour Rule
Why should a task never exceed one day? Six ways to cut work, walked through a real e-commerce returns project.
SCRUMDefinition of Done: A Quality Contract, Not a Checklist
A story we called done wrongly rejected 14.5% of withdrawal requests for 26 hours. The three layers of a DoD, who changes it, and keeping the work open when it breaks.
SCRUMDoes Scrum Make Customers Happy?
Bringing the customer inside: from 1 project to 9, from 1 person to a team of 14. A real story from the field.
SCRUMWIP Limits: Flow Control, Not a Restriction
Six people, nine open items, and only 8 of 11 cards done at sprint end. Little’s Law in practice, a limit put on the wrong column, and a flow limit of 4 that cut cycle time from 11 days to 4.5.
SCRUMMid-Sprint Work: A Budget, Not a Ban
A “no new work” rule did not stop the work; it moved it to WhatsApp. The interruption card, a measured 15% share, swapping when the budget runs out, and the only valid reason to cancel a sprint.
SCRUMProduct Owner: The Person Who Says No, Not a Ticket Writer
Seven items, all P1; 67% of sprint work came from outside the PO’s order. Putting ordering authority in writing, the stand-in PO mistake, and the line with the tech lead.
SCRUMDo You Need a Scrum Master? A Function, Not a Role
When our Scrum Master left, the daily grew from 8 to 19 minutes and blockers waited six days. How we shared the work, three things that failed, and a decision by team size.
SCRUMCycle Time: Not Velocity, the Time Your Customer Waits
Velocity rose from 34 to 52 while the customer waited 47 days for a fix. Cycle time vs lead time, p85 instead of the average, and flow efficiency.
SCRUM“When Will It Be Done?”: Not One Date, a Range of Probabilities
I said “27 March” and we went live on 5 May. Past throughput, a 20-line Monte Carlo, and how to explain “85% likely by this date” to management.
SCRUMRoadmap: Ordered Bets, Not a List of Dates
Our dated Gantt chart fell apart in the first quarter, and the one item that finished on time did not help. Now / Next / Later, with every item written as a bet with a hypothesis, a measure and a stop condition.
Team Leadership
The human side rather than the process: hard conversations, performance, what replaced authority, and what a manager is actually for in the age of AI.
See all →Technical Strategy: A No List, Not a Slide Deck
Five months after a 40-slide strategy, the answer was “Which strategy?”. One page: diagnosis, policy, steps and what we will not do this year.
LEADERSHIPThe Calendar: Focus Blocks, Not a Full Schedule
I cut meeting hours and focus time did not come back: what matters is not a full calendar but two-hour uninterrupted blocks.
LEADERSHIPEngineering Metrics: A Compass, Not a Report Card
A per-person PR dashboard got gamed in six weeks. The four DORA metrics at team level: speed and stability side by side, a direction rather than a grade.
LEADERSHIPPlatform Team: An Internal Product, Not Infrastructure
We built a platform team to end the waiting; six months later it had 63 open tickets. Golden path, internal customers and adoption rate.
LEADERSHIPRemote Teams: Written Culture, Not Cameras
The decision was made at the coffee machine; the remote engineer spent two days coding for behaviour that no longer existed.
LEADERSHIPReorgs: Choosing Communication Paths, Not Drawing Boxes
Three weeks after the reorg, the monthly statement job failed and its alert went to a team that no longer existed. An ownership map, not an org chart.
LEADERSHIPHow to Give Negative Feedback
Why does the sandwich fail? The event → impact → expectation pattern, with real dialogue.
LEADERSHIPCan You Measure Performance With OKRs?
Tie a bonus to a target and people shrink the target. Why story points inflate, and what to read instead.
LEADERSHIPNew-Generation Leadership: Authority Is Gone, Now What?
The information monopoly ended, dependence ended. What replaced them, and the power of "I do not know".
LEADERSHIPA New Engineer’s First 30 Days: The First Production Change, Not Orientation
I said “read the docs for two weeks first”; the first production change shipped on working day 23, and 14 of those days were waiting.
LEADERSHIPAI or Leadership?
Writing got cheap, verifying got expensive. The junior learning path and the leader's changed job.
LEADERSHIPSquad, Tribe, Chapter, Guild: Choosing an Org Model in One Week
The first target handed to me in a meeting with the CEO. 52 conversations, a one-sentence diagnosis, and what we left out of the Spotify model.
LEADERSHIPOne-on-Ones: An Early Warning System, Not a Status Meeting
Thirty minutes a week, and the agenda is theirs. Why "how is it going?" always returns "fine", and what to ask instead.
LEADERSHIPDeveloper to Manager: A Career Change, Not a Promotion
Promoting your best engineer can lose you twice. The right measure for how much code to keep writing.
LEADERSHIPProduct and Engineering: The Same Table, Not the Other Side
The product manager gave a date and I quietly cut the scope: the person who knows the value drops scope, and the date comes from the estimate.
LEADERSHIPDelegation: Letting Go of the Outcome, Not Handing Out Tasks
Hand work over and then hover, and you have not delegated. Authority with responsibility, and the ten-minute trap.
LEADERSHIPPsychological Safety: Measurable Behaviour, Not Good Intentions
Saying "speak freely" does not do it. Who speaks first, how late bad news arrives, and how incident reviews kill it.
LEADERSHIPLetting Someone Go: The Last Step, Not a Surprise
I told them the decision and they said “This is the first time I hear this”: written expectations, a six-week plan, a short final talk, the team and access.
LEADERSHIPConflict: Surface It, Don't Suppress It
Two senior engineers disagree on architecture and the team picks sides. Naming the conflict, separating ideas from people, and naming the decision owner in advance.
LEADERSHIPBurnout and Load: Sustainable Pace, Not Heroes
The person who saves every sprint is a single point of failure. On-call load and the signs of quiet overwork.
LEADERSHIPWhen You Depend on Another Team: A Contract, Not a Favour
“Sure, we can do that,” they said; five weeks later our work was number 23 in their backlog. Dependency maps, written commitments and joint escalation.
LEADERSHIPGrowing a Team: Five People and Fifteen Are Not the Same Job
Past seven, communication paths multiply. When to split, Conway's law, and what "two pizzas" really says.
LEADERSHIPManaging Up: Setting Expectations, Not Filing Reports
When do you say "the sprint will slip"? The arithmetic of early bad news, and shielding versus hiding.
LEADERSHIPCancelling a Project: A Decision, Not a Failure
I stopped a seven-month project three months too late: kill criteria, telling the team, and really deleting the code.
LEADERSHIPTech Lead: Not the Best Developer, the Owner of the Decision
I made our best developer the tech lead; three months later, 11 of 14 PRs were waiting for their approval.
LEADERSHIPWhen a Key Person Leaves: A Handover Plan, Not a Farewell
The only person who knew our reconciliation job resigned; I spent the first four of 30 handover days on a counteroffer, and we found the one line we missed 19 days later.
LEADERSHIPManaging Managers: A System, Not a Team
Running skip-levels without undermining the manager, filtered information, and two teams applying one rule differently.
LEADERSHIPThe Raise Conversation: Evidence, Not Bargaining
Why a counteroffer usually only delays the exit, what to say with no budget, and pay gaps at the same level.
LEADERSHIPNot a Mentor, a Sponsor
Advice is not enough: a sponsor says your name in the room you are not in, gives you visible work and takes the risk.
LEADERSHIPStaff Engineer: Scope of Impact, Not Seniority
The title changed, the calendar did not: a staff engineer’s job is to own the gap between teams.
LEADERSHIPThe Bottleneck Is Review, Not Writing: Team Speed After AI
PRs per week went from 19 to 34 and delivered work stayed flat. The bottleneck moved to review: WIP limits, the 400-line rule, the “why” section and lead time.
LEADERSHIPPostmortem: Change the System, Don’t Find the Culprit
A perfect six-page postmortem, and the same failure four months later. Where Five Whys breaks and why actions never close.
LEADERSHIPTechnical Interviews: A Rehearsal, Not a Quiz
I asked a whiteboard tree question, the candidate got stuck, we rejected them; six months later they were writing the service we integrated with. A 90-minute real task from your own codebase, a fixed question set, notes written before the meeting, and the question AI changed.
LEADERSHIPThe Career Ladder: An Expectations Table, Not a Promotion
“When do I become senior?” I said “we’ll see, you’re doing well”; four months later that sentence came back in a resignation conversation. Three axes (scope, autonomy, impact), two tracks at the same height, and why a promotion is a recognition.
LEADERSHIPTechnical Debt: The Same Queue, Not a Separate Backlog
We said “20% of every sprint goes to technical debt”; by sprint four it was zero and nobody cancelled the rule. Measuring debt by its interest instead of a percentage, three types of debt, and why not paying is a valid decision.
Engineering
Concurrency, distributed systems, messaging, scaling and coding with AI — all with real incidents and code examples.
See all →Build or Buy: Ownership, Not Cost
We said two sprints; it took seven weeks. The money ends in a draw. The decision comes from core work, the owner’s name and the exit cost.
ENGINEERINGRewriting: A Migration Plan, Not a Clean Slate
A five-month rewrite lasted four hours in production. Shadow runs, sorting differences, moving segment by segment, and when to switch the old system off.
ENGINEERINGSLOs and Error Budgets: A Negotiation Tool, Not a Target
Features or reliability? One number ended a 50-minute argument: 99.9% is 43 minutes a month, and when the budget runs out, feature releases stop for that service.
ENGINEERINGSecurity Audits: Collecting Evidence, Not Paperwork
At 23:40 the night before the audit, four engineers were still taking screenshots. Once evidence became a side effect of daily work, most answers turned into a folder path.
ENGINEERINGLLM Latency: The First Token, Not the Average
3.4 seconds on the dashboard, an 11-second empty bubble on the customer’s screen. TTFT, tokens per second, streaming and a latency budget for the first word.
ENGINEERINGLogging Prompts: Safely, Not Everything
We logged every prompt for debugging and found 2,310 national ID numbers inside. We had put 91% of the IBANs there ourselves. Reduce at the source, mask before logging, 30 days, 6 people.
ENGINEERINGRace Conditions: Why Does Stock Go Negative?
Invisible in staging, catastrophic on sale day. Six fixes, with SQL examples.
ENGINEERINGRate Limits and Fallback: A Plan, Not an Error
On an IPO morning our support assistant told one customer in three “I can’t help” for 38 minutes. RPM/TPM quotas, retries with jitter, the quality gap of a fallback, and four levels of graceful degradation.
ENGINEERINGDistributed Locks: Getting It Right
Six traps in a Redis lock, fencing tokens, and the fact that most cases need no lock at all.
ENGINEERINGLeader Election: Who Does This Job?
Four copies, all running the health check. Leases, split-brain and fencing tokens.
ENGINEERINGPrompt Cache: A Design Decision, Not a Discount
Same traffic, 2.5 times the LLM cost: the customer name had moved to the first line of the system prompt. The fixed prefix, hidden variables, hit rate and time to first token.
ENGINEERINGWorker Sharding: The Right Way to Split Work
Four workers, one at 100% CPU and three idle. Hot keys, rebalancing and ordering guarantees.
ENGINEERINGHow Pod Scaling Actually Works
Pods went from 4 to 24 and the system got slower. Why is CPU the wrong metric?
ENGINEERINGToken Dashboard: An Early Warning, Not an Invoice
The March invoice was $11,400 against a $4,000 budget, and the increase had started 25 days earlier. Four tags on every request, a daily budget and spike alert, the input/output ratio and the most expensive 1%.
ENGINEERINGHow Many Times Does a Message Arrive?
At-least-once, at-most-once and the exactly-once myth. Idempotency keys and dedup, with code.
ENGINEERINGQueue Pathologies
Poison messages, DLQs, jitter, head-of-line blocking, reordering and backpressure — all five.
ENGINEERINGHallucination in Production: Field Signals, Not Evals
The eval set passed 48 of 50 questions, and the assistant told a customer the wrong commission. Five field signals and their precision, a number check, a weekly review and feeding errors back into the eval set.
ENGINEERINGFailure Modes
Thundering herds, cache stampedes, cascades, circuit breakers, gray failure and failover loss.
ENGINEERINGDistributed Transactions: Why 2PC Blocks and Saga Saves You
One leg filled, the other rejected. Compensating transactions and the escrow pattern.
ENGINEERINGThe Model Changed Quietly: Drift, Not a Version
No deploy for nine days, same prompt, and the refusal rate went from 1.4% to 7.9%. Pinned snapshots, watching the output distribution, and 40 canary questions every morning.
ENGINEERINGThe Dual Write Problem: Outbox, Inbox and CDC
The order was written but the event never published. Why atomic dual writes are impossible.
ENGINEERINGCQRS and Materialized Views
The portfolio screen takes 8 seconds, the order path needs 3 ms. Separating reads from writes.
ENGINEERINGCrewAI: Borrowed Assumptions, Not a Ready-Made Team
A three-agent prototype worked in one day, then missed a complaint with regulatory risk: the compliance agent never saw that sentence. The same job in plain code: 71k tokens instead of 186k.
ENGINEERINGWhere Did the 200 ms Go?
Four services add up to 40 ms while the customer waits 240 ms. Correlation IDs and traces.
ENGINEERINGVibe Coding Rituals
Why does three hours of work turn into two days of debugging? Ten habits that work.
ENGINEERINGMonolith to Microservices: What Five Months Taught Us
The distributed monolith, double shipments, a cancelled order at the door, and the two services we merged back — with numbers.
ENGINEERINGLogs and Metrics in Microservices: One Screen, Not Six Log Files
Prometheus, Loki and Grafana on one screen. The four golden signals, structured logs, a 2.4-million-series cardinality accident, and why the CPU alert was useless.
ENGINEERINGDon’t Say “I Have an SMS Code, I’m Safe”: Step-Up Authentication with Passkeys for Withdrawals
The JWT was valid and $4,800 went to a new IBAN. A challenge bound to amount and IBAN, a free margin re-check, and the back door on the “add passkey” screen.
ENGINEERINGSOLID: A Tool, Not a Goal — When to Use It, When to Skip It
Two interfaces, two classes and a factory for a one-line welcome message. The five principles with code; the signals where they help, the cases where they only add files; YAGNI and the rule of three.
ENGINEERINGAgent, Local LLM, MCP Server: Who Decides, Who Executes?
An agent on an internal server that answers “how many dollars were deposited today?” with no data leaving the company. Three parts, three responsibilities; how the docstring decides tool selection, a 20/20 benchmark and the two brakes of the agent loop.
ENGINEERINGMonorepo: Team Structure, Not Code Structure
One line in the shared library, 7 bump PRs, 3 days, one service forgotten. Nine repos were right for 14 people; with 3 people they protect nobody. Why we moved from poly repo to monorepo, its five traps, the numbers 6 months later, and the real question: how many services for 3 people?
ENGINEERINGAgent Orchestrator: A Guided Flow, Not One Clever Agent
The nightly reconciliation job took 17 turns and 9 minutes in one agent, and the answer was wrong. In a 4-step flow: 2 turns, 38 seconds. Who decides, three patterns and four brakes.
ENGINEERINGMulti-Agent: Work You Can Split, Not Free Speed
We split 34 records across 4 agents: 11 minutes became 3, tokens went up 3.4 times, and two agents wrote to the same file. Split keys, the sub-agent contract and the merge step.
ENGINEERINGContext: The Right Summary, Not a Longer Window
The same question is wrong in a 118k-token window and right in a 9k one. A model does not remember, it re-reads: trim tool output, move run state to disk, and know what a summary costs.
ENGINEERINGTool Design: A Decision Surface, Not an API Wrapper
We went from 11 tools to 23 and accuracy fell from 96% to 71%. The code was fine; the menu was not. Separate decision or parameter, the four-line description, and error messages that instruct.
ENGINEERINGThe Agent Called It Twice: Idempotency, Not Autonomy
The tool answered in 32 seconds and the timeout was 30: the same withdrawal was approved twice. Who generates the key, what the second call returns, and why irreversible work is two-stage.
ENGINEERINGPrompt Injection: Input That Runs as Instruction
One sentence in a customer note reached the agent’s plan and put 3 withdrawals up for approval. Models do not separate data from instruction; the defence is in permissions, not the prompt.
ENGINEERINGThe Agent’s Trail: A Chain of Decisions, Not Logs
It took 40 minutes to find the drift in a 400-line log; now it takes 12 seconds. A run is a trace and a step is a span: what to record, how to mask customer data, how to replay a run.
ENGINEERINGEval: A Regression Test, Not a Demo
I changed one word in the prompt, the demo was perfect, and two days later 4 questions went to the wrong tool. Golden sets, exact checks, judge biases and “green but unhappy”.
ENGINEERINGPrompt and Model Versions: Code, Not Text
A “small fix” from an admin screen was a deploy with no record. Repo or config, why the model version is pinned, shadow runs and rollback thresholds.
ENGINEERINGRAG: Building Context, Not Searching
The agent stated the rule correctly; the rule had changed 14 days earlier. RAG or tool, who draws chunk boundaries, how to measure recall, and teaching a model to say “I do not know”.
ENGINEERINGAgent Cost: Cost per Task, Not per Token
“It is our own server, tokens are free” — one report kept the GPU busy for 96 seconds. Re-sent context, retries, the fixed prefix and the arithmetic of a cheap model with 3 attempts.
ENGINEERINGOn-Call: Handover, Not Heroics
03:12 at night, the alert fired and the runbook page was empty. The three questions on-call must answer, the rule that deleted 23 of 60 alerts, night authority, a 15-minute handover and the shadow week.
ENGINEERINGShipping: Release Management, Not Deploys
The rollback took 9 minutes; with a flag it would have taken 4 seconds. Separating deploy from release, four flag types and their lifetimes, a 61-flag graveyard, and automatic rollback thresholds.
ENGINEERINGSchema Changes: Two Stages, Not a Friday Night
80,000 rows in test, 47 million in production; a “five minute” migration locked the table for 40. The five steps of expand/contract, batched backfill, a table of unsafe operations and a drop-by date.
ENGINEERINGCode Review: Spreading Knowledge, Not Guarding a Gate
The PR waited three days and got 41 comments: 38 about formatting, 0 about architecture. The inverse relationship between size and value (PRs over 800 lines get FEWER comments), comment labels, the 24-hour rule and where a second approval is really needed.
ENGINEERINGArchitecture Decision Records: One Page, Not a Meeting
“Why did we do it this way?” — three people, three answers; we made the same decision twice, for different reasons. A one-page template, the rejected-options section, which decisions to record and why records are never deleted.
ENGINEERINGInheriting a System: The First 90 Days
The README was four lines and two were wrong; the answer to “how do we ship” was a name, and that person was leaving in three weeks. The single goal of week one, building the map from git, the 90-day rule and five questions for the person leaving.
Who this is for
If sprints keep spilling over and nobody looks at the retro actions; if you keep postponing the hard conversations in your team; or if your system runs perfectly in staging and falls over on the morning of a campaign — you are in the right place.
The three sections are really the same team’s three different problems: process, people and systems. And they are usually connected — the answer to why a sprint spilled over is sometimes in a queue design, and sometimes in a sentence nobody said out loud.
Every post ends with a checklist; if you are in a hurry, read only those and share them with your team.