Skip to content
Resources · Blog

Database Mistakes That Quietly Kill Startups 

Soft deletes everywhere, floats holding money, JSON blobs that became the schema, and no audit trail: the database decisions that hurt at scale.

November 3, 2026 8 min read
ArchitectureCustom SoftwareData EngineeringEngineering

The most expensive database decisions we see were all made on good days. Early in the product, two engineers moving fast, every table tidy, and a handful of choices that felt like hygiene at the time. Then the startup survives, which is the twist, because these mistakes only bill you at scale. We do rescue work on systems like this, and the invoice is remarkably consistent: four schema decisions account for most of it. None of them looks like a mistake in year one. All of them compound.

Soft Deletes on Every Table

A deleted_at column on every table feels prudent: nothing is ever really gone, mistakes are reversible, audits are possible. Three years later, every query in the system carries WHERE deleted_at IS NULL, except the handful someone forgot, which is why the dashboard and the finance export disagree by eleven rows and nobody can say which is right. Unique constraints quietly stop working, because the deleted account still holds the email address the returning customer wants to register with. Foreign keys point at ghosts. Reports differ depending on who remembered the filter.

Our position: soft delete is a tool for the few tables where the business needs undo or retention, such as orders and financial records, not a default for all of them. Where you do use it, enforce the filter in exactly one place, a database view or a default scope, so forgetting it isn't possible. For everything else, delete, or move rows to an archive table where they can't contaminate live queries.

Money in Floating Point

Somewhere in many early schemas there's a price or balance column typed as a float, because it was the default that worked. Floats can't represent most decimal amounts exactly; the errors start several places past the decimal point and surface years later as a reconciliation that's off by a few rupees across thousands of line items. We've watched a finance person chase that kind of mismatch for days, and the resolution satisfied nobody, because the answer was 'the column type,' which no amount of recounting fixes. The hours a team spends investigating a small, recurring, unexplainable discrepancy are the real cost, and they're unbounded.

The fix is old and boring: store money as integers in the smallest unit, paisa or cents, or as a decimal type with explicit precision. Store the currency beside the amount even if you only support one today. Write the rounding rule down once, in one function, and let nothing else round. Every system that handles money relearns this. The only variable is how expensively.

The JSON Column That Became the Schema

A metadata jsonb column gets added in a hurry, for flexibility, to avoid a migration on a Friday. Eighteen months later the order table's real information lives in it: delivery preferences, discount codes, status flags, three spellings of the same key written by three versions of the code, no constraints, no types, and every consumer wrapped in defensive checks for keys that may or may not exist. Querying it is slow, indexing it is partial, and nobody can say what a valid record looks like, because validity was never written down anywhere.

JSON columns are legitimate for data that's unstructured or externally shaped: webhook payloads, third-party API responses, user-defined custom fields. The line is crossed the moment your own code branches on a key inside the blob. That key is a column now; it just hasn't been migrated yet, and the migration gets more expensive every week it waits, because more code learns to read the blob directly.

No Audit Trail Until the First Dispute

The questions arrive later, and they're always the same shape. Who changed this price? When did this order's status flip, and from what? What did this record say on the day the invoice was generated? A schema that overwrites values in place cannot answer them, and the moment that matters is predictable: the first billing dispute, the first fraud incident, the first enterprise customer's security questionnaire, or the first regulator. Retrofitting history onto a system that has been destroying it since launch is somewhere between painful and impossible.

Adding it on day one is nearly free: created and updated timestamps with the actor recorded, and append-only history tables for the records that money or disputes will ever touch. You don't need event sourcing or any architecture with a name. You need the old value, the new value, who, and when, kept where the application can't edit it.

The Quieter Ones

  • Natural primary keys that turn out not to be unique or stable: phone numbers get reassigned, emails change, national IDs get mistyped
  • One users table wearing six roles, until a customer and an admin are the same row with different flags and the permissions logic lives everywhere
  • Timestamps stored without timezones, discovered during the first customer outside your country
  • Validation that lives only in application code, so the database happily accepts whatever the one unvalidated script inserts
  • Indexes added only after the first slow-query crisis, by whoever is on call that night

When to Bring In Help

Most of this doesn't need a consultant. A CRUD product with modest volume survives imperfect schema decisions fine, and premature schema perfectionism is its own disease. The moments that justify outside eyes are specific: when the data model starts carrying money, inventory, or anything an auditor will someday read; before a migration that rewrites history rather than adding to it; and when query performance starts dictating product decisions instead of the other way around. A meaningful share of our custom software engagements begin as exactly that review, a week of reading the schema and the queries before anything gets built. If you're past prevention, the situation is still recoverable: we've moved a decade-old schema out from under a live logistics business without stopping it, so none of these mistakes is fatal. They're just priced by how long they're left to compound, and the schema is the one part of a startup that never stops charging interest.

Have a project that needs this kind of thinking applied to it?