A pure CRUD application scores zero.

That's not a critic of domain-driven design talking. It's Vaughn Vernon, in the first chapter of Implementing Domain-Driven Design, the book half the industry calls "the red book." He gives you a scorecard for deciding whether your project deserves DDD, and the lowest row is for an application that is "completely data centric and truly qualifies for a pure CRUD solution." Points for that row: 0. You need 7 before he says you should seriously consider DDD.

Here's the part that surprises people. Every major voice in the DDD world has said some version of this. Eric Evans, Martin Fowler, Udi Dahan, Microsoft's own reference architecture. The warning is right there in the source material. It just doesn't survive the trip into conference talks and starter templates, where "we do DDD here" turns into five layers wrapped around a table with six columns.

This article is about the cases where that ceremony isn't worth it, why, and the harder question: how to tell when a service that was fine as CRUD has quietly grown into something that needs a real model. It's the flip side of the modeling pieces on this site. If you want the case for the patterns, Aggregate Design and Modeling a Credentialing Workflow as a Domain make it. This one is about when to leave them in the drawer.

Note
A quick honesty note. The idea for this piece started as "real cases where DDD wasn't worth it." The scenarios below are hypotheticals built from the published guidance, not war stories, and every quote and example is from a source you can check.

The people who wrote the book already said no

Start with the sources, because they're more blunt than their reputation.

Eric Evans, 2003. The original Domain-Driven Design book describes an approach it calls the Smart UI, where business logic lives directly in the screens and the database is the integration point. Evans labels it an "anti-pattern," but with obvious irony, because he then lists its advantages: "Productivity is high and immediate for simple applications," and "Less capable developers can work this way with little training." He says it fits projects that are simple, "dominated by data entry and display, with few business rules." He calls it "an alternate, mutually exclusive fork in the road." Not a failure. A different road.

Eric Evans, 2009. At QCon London, in a talk titled "What I've learned about DDD since the book," Evans said the building blocks, meaning value objects, entities, factories, repositories, and services, were "over emphasised." He also said: "Not all of a large system will be well designed, but parts of the system can be properly designed." The job is picking which parts.

Martin Fowler, 2003. In Patterns of Enterprise Application Architecture, Fowler compares Transaction Script and Domain Model and gives the rule of thumb people still quote: if you have "simple not-null checks and a couple of sums to calculate," a Transaction Script "is a better bet."

Udi Dahan, 2009. In an MSDN Magazine piece called "Employing the Domain Model Pattern," Dahan names "the No. 1 most common fallacy": "Any persistent object model is a domain model." He also says flatly that "one reason not to make use of the domain model pattern is if the business your software is automating does not change much."

Microsoft's reference app. The eShopOnContainers sample, which Microsoft built specifically to teach microservices on .NET, uses DDD patterns in its ordering service and deliberately does not use them in its catalog service. The accompanying architecture guide says: "if your microservice or Bounded Context is very simple (a CRUD service), the anemic domain model in the form of entity objects with just data properties might be good enough, and it might not be worth implementing more complex DDD patterns."

So the premise that DDD is a universal best practice isn't a position any of its main authors actually hold. They all describe it as a tool for complex, changing business logic, and they all tell you to do something simpler everywhere else.

Vernon's scorecard, paraphrased from chapter 1, is the most concrete version of the test:

If your project looks like... Points
Completely data-centric, every operation is a simple create, read, update, or delete 0
30 or fewer business operations, with little logic in them 1
Around 30 to 40 user stories or use case flows 2
Hints of moderate complexity that might grow 3
Features that will keep changing frequently over years 4
A new domain nobody on the team fully understands yet 5

The threshold is 7. Notice what the rows measure: volume of behavior, rate of change, and how much you don't know yet. Not team size, not traffic, not how "enterprise" the codebase feels. His other test is even shorter: if you could build the thing quickly in Rails or Grails "and not feel the pain of lacking power and control over complexity and change," you probably don't need DDD.

What the ceremony looks like on a service that doesn't need it

Let's make this concrete. Imagine a venue directory service. Staff add venues, edit their address and capacity, archive the ones that close. Other services read the list. That's it. No pricing, no approvals, no workflow, no state machine.

Now imagine it was built "properly," because the team template says every service gets the full DDD treatment. In NestJS with @nestjs/cqrs, the update path might look like this:

src/venues/domain/venue.ts

export class Venue { private constructor( private readonly _id: string, private _name: string, private _address: string, private _capacity: number, private _archived: boolean, ) {} static rehydrate(props: VenueProps): Venue { return new Venue(props.id, props.name, props.address, props.capacity, props.archived); } rename(name: string) { this._name = name; } relocate(address: string) { this._address = address; } changeCapacity(capacity: number) { this._capacity = capacity; } get id() { return this._id; } get name() { return this._name; } get address() { return this._address; } get capacity() { return this._capacity; } get archived() { return this._archived; } } 

src/venues/application/update-venue.handler.ts

@CommandHandler(UpdateVenueCommand) export class UpdateVenueHandler implements ICommandHandler<UpdateVenueCommand> { constructor(@Inject(VENUE_REPOSITORY) private readonly venues: VenueRepository) {} async execute(cmd: UpdateVenueCommand): Promise<void> { const venue = await this.venues.findById(cmd.id); if (!venue) throw new NotFoundException(); venue.rename(cmd.name); venue.relocate(cmd.address); venue.changeCapacity(cmd.capacity); await this.venues.save(venue); } } 

Plus a VenueRepository interface, a Postgres implementation of it, a VenueMapper that converts rows to Venue and back, an UpdateVenueCommand class, the controller, and the module wiring. Call it eight files to change three columns.

Look at what each layer is defending. The entity's methods are setters with nicer names. rename doesn't check anything. changeCapacity doesn't know what a valid capacity is. The repository abstracts over one database you'll never swap. The mapper copies fields in a circle.

This is exactly what Fowler described in his "AnemicDomainModel" bliki entry in November 2003: objects "named after the nouns in the domain space," with "hardly any behavior on these objects, making them little more than bags of getters and setters." His verdict on it is the line worth remembering: an anemic model incurs "all of the costs of a domain model, without yielding any of the benefits."

That's the real failure mode. Not "we didn't use DDD." It's "we paid for DDD and got a transaction script anyway, spread across eight files." Every new field is now a five-file change. Every new engineer has to learn the layering before they can add a column. And nothing in those layers is protecting a rule, because there aren't any rules.

The same service, as a transaction script

Here's the version Fowler and Dahan are pointing you toward. One module, plain SQL, the database doing the work it's good at:

src/venues/venues.service.ts

import { Pool } from 'pg'; export interface VenueInput { name: string; address: string; capacity: number; } export class VenuesService { constructor(private readonly pool: Pool) {} async update(id: string, input: VenueInput) { const { rows } = await this.pool.query( `UPDATE venues SET name = $2, address = $3, capacity = $4, updated_at = now() WHERE id = $1 AND archived = false RETURNING id, name, address, capacity`, [id, input.name, input.address, input.capacity], ); return rows[0] ?? null; // null -> controller returns 404 } async archive(id: string) { const { rowCount } = await this.pool.query( `UPDATE venues SET archived = true WHERE id = $1 AND archived = false`, [id], ); return rowCount === 1; } } 

And the "rules" live where they're cheapest to enforce and hardest to bypass:

migrations/001_venues.sql

CREATE TABLE venues ( id uuid PRIMARY KEY DEFAULT gen_random_uuid(), name text NOT NULL CHECK (length(name) BETWEEN 1 AND 200), address text NOT NULL, capacity integer NOT NULL CHECK (capacity > 0), archived boolean NOT NULL DEFAULT false, updated_at timestamptz NOT NULL DEFAULT now() ); 

Input validation still happens at the edge, with whatever you already use for DTOs. But notice that this version actually enforces more than the eight-file one did. The capacity rule exists. It's in a CHECK constraint that every writer hits, including the migration script someone runs by hand at 11pm, which never goes through your aggregate.

This is the Transaction Script pattern, and Khononov's Learning Domain-Driven Design (O'Reilly, 2021) is worth reading on it, because he presents it as a legitimate DDD-era choice, not a lapse. His design heuristics include a decision tree for picking a business logic pattern, and mapped onto subdomain types it roughly goes:

  • Supporting or generic subdomain, simple data: Transaction Script.
  • Supporting or generic subdomain, complex data structures: Active Record.
  • Core subdomain with complex business logic: Domain Model.
  • Core subdomain where you need money tracking, an audit log, or deep history analysis: Event-sourced Domain Model.

That's a paraphrase of a tree that has a few more branches for architecture style, but the shape is the point. Choosing Transaction Script for a venue directory is DDD's own strategic advice applied correctly: spend modeling effort where the business is complicated, and nowhere else.

Decision tree: supporting or generic subdomains go to Transaction Script or Active Record depending on data complexity; core subdomains go to Domain Model or Event-sourced Domain Model depending on money, audit log, or history needs

The invariant that belongs in the database, not the aggregate

One gotcha catches nearly every team that models everything. Dahan uses it in his 2009 article, and it's the cleanest example there is: a user's email address must be unique.

It feels like a domain rule. It's written in the requirements. So it goes in the domain layer:

src/users/application/register-user.handler.ts

async execute(cmd: RegisterUserCommand) { const existing = await this.users.findByEmail(cmd.email); if (existing) throw new ConflictException('Email already registered'); const user = User.register(cmd.email, cmd.name); await this.users.save(user); } 

This compiles. It passes every unit test you'll write for it. And it's broken, because it's a check-then-act race. Two registration requests for the same address arrive a few milliseconds apart. Both run findByEmail, both get nothing back, both insert. Postgres runs at READ COMMITTED by default, so neither transaction sees the other's uncommitted row. You now have two users with the same email and a domain model that swears it prevented this.

Dahan's reasoning about why this doesn't belong in the model is the more interesting part. The domain model, in his framing, exists to capture business behavior "subject to change." Email uniqueness will almost certainly never change. Putting it in the part of the system built for volatile rules "makes little sense, may be difficult to implement, and might not perform that well." His conclusion: "A unique constraint in the database would suffice."

It does more than suffice. It's the only version that's actually correct under concurrency without taking heavier locks:

migrations/002_users_email_unique.sql

CREATE UNIQUE INDEX users_email_unique ON users (lower(email)); 

src/users/users.service.ts

const UNIQUE_VIOLATION = '23505'; // Postgres SQLSTATE unique_violation async register(email: string, name: string) { try { const { rows } = await this.pool.query( `INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id`, [email, name], ); return rows[0]; } catch (err: unknown) { if ((err as { code?: string }).code === UNIQUE_VIOLATION) { throw new ConflictException('Email already registered'); } throw err; } } 

The index on lower(email) also handles the case the in-memory check usually forgets, Ann@example.com versus ann@example.com. The general lesson reaches well past emails: a lot of what gets modeled as aggregate invariants on simple services is really uniqueness, referential integrity, non-null, or a range check. Databases have enforced those for decades, atomically, for every writer. An aggregate that re-implements them in application code is slower, racier, and easier to bypass.

This is also the honest answer to "but where does the business logic go?" in a CRUD service. Some of it is constraints. Some of it is validation at the edge. And if there's genuinely nothing left after that, you don't have a domain model problem. You have a table.

Four shapes of service where the model isn't worth it

These are hypotheticals, but each one maps onto a specific piece of the guidance above.

1. Reference data and back-office editors

Country lists, product categories, venue directories, feature flag admin screens, CMS-style content. This is Vernon's zero-point row and Evans's "data entry and display, with few business rules." The users are editing records, and the records are the product. A generated admin, a thin REST layer, or a transaction script per endpoint is the right amount of design.

2. Anything that wraps somebody else's domain

A service whose job is to call Stripe, send email through a provider, or sync with an identity platform. The real rules live in the vendor. In DDD's own vocabulary this is a generic subdomain: needed, but nothing special to your business. Modeling Stripe's concepts as your own aggregates just gives you a second, worse copy of their model to keep in sync. What you want at that boundary is a translation layer, which is still a DDD idea (an anti-corruption layer), not a rich model behind it.

3. The read side of almost anything

Dahan makes this point in the same 2009 article: "Showing user information involves no business behavior and is all about opening up that data." Search screens, dashboards, list views, and exports don't need to go through entities at all. Query the tables, or a view, and shape the result for the screen. You don't need full CQRS to take this advice; the trade-offs of going further are in CQRS in NestJS: When It's Worth the Complexity.

4. Code you're planning to throw away

A proof of concept, an experiment, a service with a known expiry date. Microsoft's CRUD microservice guide explicitly allows for this: "Perhaps the problem to solve is simple, or perhaps the implementation is only a proof of concept." Tactical DDD is an investment in making future change cheap. If there isn't meant to be a future, don't pay for one. Sacrificial Architecture covers how to build that kind of service so it actually gets deleted.

The trap on the other side: Evans's one-way door

Here's where the "just do CRUD" crowd gets it wrong, and it's in the same chapter where Evans defends the Smart UI. Right after listing its advantages, he gives the catch: "you can't migrate to another design approach except by replacing entire applications." He also warns that with Smart UI, "Complexity buries you quickly, so the growth path is strictly toward additional simple applications."

So there are two kinds of "no DDD," and they're not equal:

  • Smart UI style: logic smeared across controllers, templates, and stored procedures, business rules duplicated in every screen that needs them. Fast today, and a rewrite the day the rules show up.
  • Transaction script behind a clean service boundary: one function per operation, one place per operation, the database enforcing what it can, and nothing leaking into the transport layer. Just as fast today, and refactorable later.

The second one is what Fowler means when he says Transaction Script is the "better bet" for simple logic. It's simple, but it's not scattered. Each operation is a readable procedure, so when real rules arrive you can find every place that needs to change. That's the whole difference between a deliberate choice and a hole you'll have to climb out of.

My position: default to the transaction script for anything that scores low, and put your design energy into keeping it in one place rather than into layers. Layers you add before there's logic to protect aren't future-proofing. They're a tax on every change that you pay until the logic arrives, and the logic might never arrive.

The signals that it's time to upgrade

A CRUD service rarely stays exactly CRUD. The trick is noticing the moment it stops. Dahan's article has the best example of what the first real rule looks like: "a customer may have no more than $1,000 in unpaid orders." He points out what makes it different from the email rule: it "involves multiple entities and would need to be evaluated in a variety of use cases." Then he adds that an account manager can override it, so rules start overriding other rules.

That gives you a practical checklist. Start reaching for a model when you see:

  1. The same if in more than one handler. The unpaid-orders check appears in checkout, in the admin order editor, and in the bulk import. That duplication is one of the Smart UI disadvantages Evans lists: the same rules copied into every operation that needs them.
  2. A rule that spans rows the database can't constrain together. A CHECK constraint sees one row. "Total unpaid across all of this customer's orders" doesn't fit in one.
  3. Rules with exceptions and exceptions to the exceptions. Once domain experts start saying "unless," you're past validation and into policy.
  4. Rules that keep changing. Vernon's 4-point row, and the reason Dahan says the domain model exists at all: to make volatile business behavior cheap to change.
  5. Vocabulary drift. The business says "hold," "release," and "lapse," and your code says status = 3. That gap is exactly what ubiquitous language is for.

And when the signals fire, upgrade the part that fired, not the whole service. Pull the one rule into one small, pure piece of code that every operation calls:

src/orders/credit-policy.ts

export const UNPAID_LIMIT_CENTS = 100_000; // $1,000 export function canPlaceOrder(input: { unpaidCents: number; orderCents: number; placedByAccountManager: boolean; }): boolean { if (input.placedByAccountManager) return true; return input.unpaidCents + input.orderCents <= UNPAID_LIMIT_CENTS; } 

That's a policy with no framework, no repository, and no mapper, and it's already doing the job the eight-file venue service pretended to do. If more rules gather around the same concept, they'll pull toward each other, and at that point you'll have a real reason to introduce an entity with behavior and to think about where its consistency boundary goes. That's when the aggregate design questions start earning their keep, not before.

Skip the tactics, keep the strategy

One last distinction, because "DDD is the wrong tool" is usually only half true. Evans's 2009 complaint was that the tactical building blocks got too much attention. What he called essential was different: "Creative collaboration of domain experts and software experts."

The strategic side of DDD is almost free, even on the venue directory. Talking to the people who use it costs an afternoon. Naming things the way they name them costs nothing. Knowing that "venue" in the directory and "venue" in the booking system mean different things, and keeping them from sharing a table, is a bounded-context decision that saves you real pain later, CRUD or not. Bounded Contexts in a Real Codebase goes into where those seams actually go.

What's expensive is the tactical kit: aggregates, repositories per aggregate, domain events, mappers, command buses. Those pay off where rules are complex and changing, which is Evans's core domain. On a table with six columns, they're the surgeon's tray next to a box that needs tape.

So the next time a template hands you eight files for three columns, run Vernon's scorecard honestly. If it comes out near zero, write the transaction script, put the invariants in the schema, keep each operation in one place, and watch for the first rule that shows up in two handlers. That's not skipping DDD. It's the part of DDD most people skip.

Originally published at andriiboyko.com.