Essays on software architecture, digital commerce, and the systems we build now.
Configuration is code with a weaker deployment process -- why tax tables, pricing rules, and admin-panel settings deserve types, validation at authoring time, and a deterministic evaluator.
Why four thousand green tests can still miss a business rule -- and how DDD, BDD, TDD, and property-based testing turn an unnamed assumption into an executable specification.
Why treating Instant.now() as a plain value instead of an explicit input is a silent source of pricing and business-logic bugs in commerce systems.
Why exactly-once delivery is impossible over an unreliable network, and how modeling an effect as a function of its intent -- not bolting on dedupe infrastructure -- is what actually makes a retry safe.
Why commerce platforms should give large action models a small, governed set of typed actions rather than broad endpoint access — separating authentication from authority, and deciding before executing.
Why agent-facing commerce platforms should model business capabilities as a typed algebra before mapping them onto any protocol -- MCP, UCP, or otherwise.
Why the real cost of composed commerce systems isn't integration or maintenance, but the incident cost of reconstructing a coherent business story from many locally-true systems — and how functional, event-driven design reduces the interest rate on that ambiguity.
Why modeling money as a bare number instead of a typed Amount or Price with currency and precision is the real source of bugs that later look like unit or locale problems.
Why commerce systems that read fine to a human buyer routinely fail to give a purchasing agent a decision it can safely act on -- and how algebraic data types close that gap.
How a mediating architectural pattern called capability surfaces reduces agent-merchant integration complexity from O(A×M) to O(A+M), enabling any compliant agent to transact with any compliant merchant without bespoke integration.
An examination of what changes when humans delegate purchasing authority to autonomous software agents, and the accountability, oversight, and trust infrastructure required for agent-mediated commerce to function within organizational contexts.
An analysis of how agent-mediated purchasing restructures competitive dynamics in B2B markets, shifting competition from attention capture and UX investment toward data completeness, interface reliability, and fulfillment accuracy.
A layered protocol stack perspective on agentic-commerce interoperability: MCP as a general capability mechanism, commerce-domain profiles as shared vocabulary, and capability registries as discovery infrastructure.
Your next customer might not be human — and that changes everything about how you compete.
A practical examination of whether adopting functional programming principles materially reduces enterprise risk and improves delivery predictability.
How pragmatic domain models accumulate impossible states over time, and why algebraic data types prevent them by design.
How immutable event journals combined with pure fold functions create accountability by design in commerce systems.
Why modeling business outcomes with Either instead of exceptions preserves meaning, enables auditing, and makes systems easier to trust.
How Option types model legitimate absence more honestly than null, eliminating hidden assumptions and defensive code throughout a system.
How algebraic data types and pattern matching let the compiler enforce business logic completeness, eliminating entire categories of runtime errors in commerce systems.
How map, filter, and flatMap eliminate loop mechanics to expose pure business logic, making commerce transformation pipelines readable and predictable as they grow.
How the shift from human to automated agent-based commerce requires systems to expose stable capability surfaces rather than internal microservice plumbing.
How shifting from statement-based to expression-based thinking eliminates hidden state and cognitive overhead in system design.
How pure functions — same inputs, same outputs, no side effects — eliminate entire categories of concurrency bugs and make pricing, eligibility, and promotion logic reliably testable at scale.
Why treating values as immutable facts — not mutable records — is the architectural foundation for distributed systems that behave predictably under concurrency, deployment, and time.
An exploration of why functional programming principles address modern software development challenges, including distributed systems, and state management — moving beyond purely academic applications.
How applying reactive microservice architectures can invigorate digital commerce platforms and where it makes the most difference.
Strategic guidance on implementing headless commerce architectures without losing sight of business outcomes.
Making a headless commerce decision for the whole business, not just the engineering team.
Exploring microservices architecture, system boundaries, and the practical realities of decomposition in commerce platforms.
Contemplation of a COVID-19 vaccine distribution and administration plan that attempts to optimize need and effectiveness, and where blockchain might fit.