Why Your Software Projects Fail: A Hard Truth Most Teams Ignore
The excitement of a new project: The team gathers, technical terms fly around, and everyone is eager to decide on frameworks and architecture.
Sound familiar?
A guest cancels a reservation. Months later someone claims the cancellation period had already ended. The system shows status = cancelled. It cannot show which context was considered, which rule applied, or whether that context still held when the outcome was recorded.
A business decision becomes explainable when the application makes its processing path explicit.
The command expresses the intention. The Domain Capability defines the responsibility, the rules, and the possible outcomes. The Request Processing Unit (RPU) obtains the relevant context, invokes the decide function, protects that context during the commit, and records the accepted outcome or returns the rejection. A rejection is a valid business answer, not an error.
Storage remains an explicit implementation decision. Relational transactions and constraints, or a conditional append on an event store, fulfill the same obligation: the outcome must not be recorded after the basis for the decision has become invalid. Event Sourcing is one way to meet that obligation, not a prerequisite.
Explaining a decision months later may also require retaining the outcome, the applicable policy version, and enough of the relevant context to show why the result was valid at that moment. How much depends on business, legal, and operational requirements. The RPU gives that information a clear place.
A system that retains only the latest values discards the information its decisions relied on. A system with an explicit path from intention to outcome can answer the question every challenged decision raises: why.
Full article: https://t.co/gvKySRkJB7
An event is fact that states a happening: something changed in the domain, and the event names it in domain language and in past tense: ReservationConfirmed, not ReservationUpdated.
The generic name keeps the mutation and loses the reason; the domain name preserves which business situation occurred. Every event is a fact, and every fact is data. Not every fact is an event: a listing's maximum of four guests is a fact with no happening behind it, while the confirmation of a reservation is both. An event can carry two times, the moment the happening occurred and the moment the system recorded it, and the two can differ.
The event is a modeling concept, and storage is a separate decision. Thinking in events means following how the business facts unfold over time before choosing any internal structure. Storing the events themselves as the authoritative record is Event Sourcing; current state is then derived by replaying them, a left fold over the history. It is one possible storage of Application State and no requirement.
Read my full article here:
https://t.co/LsAedZWQ4J
ORMs are not just a technical compromise. They are the result of a flawed underlying assumption in enterprise object-oriented architecture: that the Domain should be represented as a mutable object model.
Once you understand that stored data represents the Application State, this assumption becomes questionable. The system already has an authoritative representation of the state it relies on. Creating a second representation as an object graph, and then mapping between the two, is not domain modeling. It is architectural nonsense.
Most descriptions of Event Sourcing still start with aggregates.
But the original definitions never required them. The aggregate is a specific implementation choice treated by the DDD community but not part of the definition.
#eventsourcing#ddd#dcb
If software is used through Commands and Queries, why attach those interactions to a centralized object model? The interaction can become the starting point, with context built locally from the facts required for that decision. #programming#ccc#ddd
https://t.co/D2ArkCdEXp
Domain Capabilities are autonomous internal processing units that encapsulate one specific business responsibility of the domain. Each capability owns the complete decision process for one domain request. https://t.co/xpkBdX9Trf
#eventsouring is an approach to persistence where every change in application state is recorded as an immutable event, rather than overwriting state in place.
Instead of storing the latest snapshot of each object, an event-sourced system stores a sequence of events that describe all state changes.
Stop thinking in CRUD.
It’s how we used to build apps:
•Model the data
•Add tables
•Expose endpoints
•Done
But CRUD flattens everything into database ops, event when it isn’t.
Pause a subscription? → Not an update Reject a delivery? → Not a delete Approve a refund? → More than a flag flip
We’re not building forms for data entry anymore.
What should we be doing instead?
✅ Automating behavior
✅ Tracking decisions
✅ Connecting workflows
The real world doesn’t CRUD.
So why should your code?
💬 Curious? I wrote more about this → https://t.co/vMyKZxzIs0
📷 Image credit: Nadezhda Kozhedub (iStock)
Are you solving real problems, or engineering for imaginary scenarios?
Over-engineering is not "future-proofing"! It's the quickest path to unnecessary complexity, wasted effort, and frustrated teams.
Instead, focus relentlessly on what's right in front of you: the real challenges your users are facing today.
- Don’t optimize prematurely; optimize when your data shows a clear bottleneck.
- Avoid abstracting too early; solve today's concrete problem first.
- Let real user feedback guide your architecture, not theoretical perfection.
What's your approach to avoiding over-engineering on your team? How do you keep complexity under control while staying ready for growth?
https://t.co/arjxyxsIBZ
Real-world software has taught me that pragmatism beats dogma. We should focus on delivering business value, keeping things simple, and only introducing complexity (like abstractions) when proven necessary.
Thoughts?
I've been in the software business for about three decades now. That's long enough to see all sorts of trends come and go.
I feel that the industry has lost sight of what is truly important. Instead of solving real problems in a simple way, we keep piling on new frameworks and buzzwords.
We seem more interested in following the latest fad than in producing software that helps people and businesses.
Your thoughts?