Thoughts

What I have learned from building, debugging, scaling, and untangling software over the past two decades. The subjects range from code and tests to architecture, operations, and the business constraints behind technical decisions.

  1. Testing the Go Port Against PHP
  2. Retire the Browser, Keep the Test Runner
  3. Recover the First Useful Service, Not Every Server
  4. A Rewrite Can Change Data Without Changing the Price
  5. Replication Copies Corruption Too
  6. A PHP Test File Isn't One Migration Case
  7. The Migration Plan Was Solving the Wrong Problem
  8. When the Framework Sets the Latency Floor
  9. A Backup Is Only an Input to Recovery
  10. Repository Evidence Is Not an Instruction
  11. Is Your Benchmark Doing New Work?
  12. A Cache Hit Still Has a Payload
  13. Index Tariffs Without Losing Charges
  14. Implementation Without Understanding Is Borrowed Code
  15. Compile Published Rules Before the Quote Arrives
  16. AI Should Shorten the Evidence Loop
  17. The Order of Charges Changes the Price
  18. Quality Needs a Risk and Capacity Budget
  19. One Parcel Doesn't Have One Pricing Weight
  20. The Engine Prices Parcels, Not Copies
  21. Choose a Stack from Constraints, Not Identity
  22. A Valid Pricing Row Can Still Be Wrong
  23. Not Every Pricing Rule Belongs in a Formula
  24. A Decision Record Needs a Way Back
  25. How a Shipping Quote Gets Its Price
  26. A Short-Lived Token Can Still Have a Large Blast Radius
  1. A Lockfile Gives Repeatability, Not Provenance
  2. Supply-Chain Security Begins with Who Can Change the Artifact
  3. Rollback Cannot Restore a Contract You Already Removed
  4. Observability Must Answer the Next Operator Question
  5. From Commit to Changelog: An Intent-Aware Release Pipeline
  6. Unreleased Is Not a Junk Drawer
  7. A Pull Request Is a Review Narrative, Not a Template
  8. Intent Commits: Commit Types Are Not Release Decisions
  9. A Cache Hit Is Not a Freshness Guarantee
  10. Octane Removes Repeated Boot and Adds State
  11. Eager Loading Is Not a Query Shape
  12. A Worker Count Is Not a Throughput Plan
  1. Cache the Deployment, Not the Assumption
  2. A Slow Request Is Not a Capacity Plan
  3. Boundaries Follow Work Without Becoming Destiny
  4. Enforce Architecture at the Cheapest Reliable Layer
  5. Name the Independent Thing
  6. A Module Is Cheaper Than a Network Boundary
  7. Decompose by Change, Not by Layer
  8. A Design Is Good for a Change, Not in Isolation
  9. A Characterization Test Is a Boundary, Not a Recording
  10. A Surviving Mutant Is a Question, Not a Score
  11. An Interface Does Not Make a Fake Substitutable
  12. A Mock Fortress Tests a Call Script
  1. Choose the Test Boundary from the Defect
  2. Coverage Tells You What Ran, Not What Your Tests Would Catch
  3. Test Process State, Not Message Choreography
  4. A Process Manager Remembers What the Queue Cannot
  5. An Outbox Moves the Failure Window
  6. Publishing Events Is Not Event Sourcing
  7. A Domain Event Is a Fact, Not a Question
  8. CQRS Starts When Reads Need a Different Model
  9. A Queued Command Changes the Contract
  10. A Command Bus Must Pay for Its Indirection
  11. A Valid Command Can Still Be Refused
  12. A Version Column Is Not Concurrency Control
  1. Loading State Is Not Creating It Again
  2. A Mapper Connects Two Honest Models
  3. A Repository Is a Domain Collection, Not an ORM Wrapper
  4. A Composition Root Makes Choices Visible
  5. A Hexagon Is Not a Directory Layout
  6. An Open Host Service Is Not a Published Language
  7. An API Cannot Tell You Who Has Influence
  8. An Anti-Corruption Layer Must Own the Translation
  9. A Context Map Must Say What the Arrow Means
  10. Shared Kernel or Published Language: Choose Where Coordination Lives
  11. EventStorming Finds Disagreement Before It Finds Services
  12. Entity, Value Object, Aggregate, Model, DTO: Name the Role
  1. A Constructor Should Leave a Usable Object
  2. A Null Object Should Mean Nothing Happened
  3. The Law of Demeter Is About Knowledge, Not Dots
  4. Tell, Don't Ask Means Keep the Decision with the State
  5. Strategy Chooses How; Command Records What to Do
  6. Composition Over Inheritance Is a Decision, Not a Rule
  7. Dependency Inversion Lets Policy Own the Boundary
  8. Interfaces Belong to Their Clients
  9. Substitution Is a Behavioral Contract
  10. Open–Closed Protects Stable Policy from Repeated Variation
  11. Single Responsibility Is About Change, Not Class Size
  12. A Design Principle Is a Compressed Failure History
  1. Design Becomes Valuable When the Next Change Arrives
  2. The Type a Caller Receives Defines the Role
  3. A Method Should Tell You What Changed
  4. Construction Should Not Hide Durable Writes
  5. Global State Makes Local Reasoning Impossible
  6. Framework Convenience Has a Boundary
  7. Dependencies Should Be Visible at Construction
  8. A Service Class Can Become a Procedural Junk Drawer
  9. A Primitive Can Hide a Domain Decision
  10. Boolean Parameters Hide Different Operations
  11. Invalid State Should Be Difficult to Construct
  12. A Class Name Should Describe a Role
  1. Stored Data Is a Caller You Cannot Find with Code Search
  2. The Strangler Pattern Still Needs an Exit Plan
  3. Deprecation Is a Migration, Not a Warning
  4. Static Analysis Turns Assumptions into Questions
  5. A Code Review Should Test the Decision, Not the Author
  6. A Small Change Limits the States a Reviewer Must Hold
  7. Technical Debt Is a Change Tax You Can Name
  8. A Rewrite Needs a Behavior Ledger
  9. Parallel Implementations Are Not a Replacement Seam
  10. A Characterization Test Is Not a Product Decision
  11. A Characterization Suite Is Scoped to a Change
  12. A Directory Map Is Not a Redesign Plan
  1. A Capability Interface Is Smaller Than a Vendor Client
  2. Renaming a Field Is a Protocol Migration
  3. A Cache Must Distinguish Empty from Unavailable
  4. Partial Work Needs a Child Ledger
  5. Retry Budgets Multiply Across Layers
  6. A Rate Limit Belongs to All the Workers Sharing It
  7. An Idempotency Key Is Not an Identity
  8. A Webhook Delivery Is Not a Unique Event
  9. Map External Data Before It Enters Your Model
  10. Validate at the Boundary You Control
  11. A Third-Party API Is an Unreliable Collaborator
  12. An HTTP 200 Does Not Mean the Operation Succeeded
  1. Data Outlives the Code That Created It
  2. Audit History Is Different from Application Logging
  3. An Index Must Serve a Real Query
  4. Pagination Needs a Stable Order
  5. Soft Deletes Preserve Ambiguity Too
  6. An Identifier Should Outlive Its Storage Engine
  7. Time Zones Are Part of the Data Model
  8. Money Is Not a Floating-Point Number
  9. Null Is a Domain Decision
  10. A Migration Is a Production Change
  11. A Transaction Defines What Must Succeed Together
  12. Let the Database Reject Impossible State
  1. Debugging Ends with an Explanation, Not a Green Build
  2. A Release Gate Must Fail Before Incompatible Code Goes Live
  3. Test Cannot Prove Production When It Runs Different Rules
  4. A Correlation Identifier Is a Boundary Contract
  5. Retries Can Multiply the Original Failure
  6. A Timeout Is Part of the Contract
  7. Silencing an Error Does Not Protect the Customer
  8. Runtime Configuration Is Process State
  9. A Failure Timeline Can Eliminate the Best-Looking Suspect
  10. Logging Is a Workload, Not a Side Effect
  11. Production Bugs Can Live in the Data, Not the Code
  12. Reproduce the Failure Before Repairing It