Skip to content

BuildNot yet confirmed elsewhere1 publisher3 min readPublished

Object or file storage: the wrong pick stays quiet until inode exhaustion

A dev.to writeup reduces the storage choice to a property test on the calling code. The part worth arguing about is when each wrong answer shows up: on the first query, or at 10 million files.

The Engineer · Build desk

How we use AISend a correction

What happened

  • Its worked example is user photos on an ext4 volume, where the server falls over at 10 million files and inode exhaustion is the named mechanism.
  • Databases are the stated exclusion: object storage has millisecond latency and no in-place mutation, so relational engines on S3 perform badly outside Iceberg and Delta.
  • The mount-based escape route is partial. The author says mount layers misreport in small ways, and RustFS documents no FUSE driver.

Why it matters

  • constraint Keeping the option open does not work. Two of the four filesystem properties the post says databases need are the two object storage lacks, so "we will move the database onto the bucket later" is...
  • cost The correction is billed to the filesystem side, since the object route needed no code change across four orders of magnitude.
  • decision The asymmetry in detection time argues for spending the design hour on the storage question before the first upload, because only one of the two errors will announce itself while anyone is still...
  • exposure Teams planning to bridge the gap with a mount take on whatever the mount layer gets wrong, and at least one S3-compatible server does not offer that layer at all.

The useful part of this comparison is not the requirement lists, it is when each mistake becomes visible. Put a database on object storage and the error reports itself early: the dev.to writeup by Ethan Carter puts object latency at millisecond level with no in-place mutation [6], against the sub-millisecond random reads, in-place byte updates, ordered fsync and lock files that PostgreSQL, MySQL, MongoDB and SQLite expect from a filesystem or block device [7]. Two of those four properties are precisely the ones object storage does not have [20]. Put user photos on an ext4 volume instead and nothing reports anything at all until inodes run out [1]. One error costs you a slow afternoon in development. The other costs an afternoon two years later, on a volume somebody else provisioned.

The two anecdotes in the post are the same workload an order of magnitude apart. The filesystem falls over around 10 million files [21]; the bucket holding the same photos reached 100 million [22], a 10x gap on identical data [23]. And the object path got there without a code change [10], which tells you where the migration work lives. It is not on the side that scaled.

So the test runs against the caller, not the data. The operating system opens, reads, writes and seeks; it does not issue HTTP PUTs, and Carter's advice is not to fight that [8]. His own shorthand is that random writes and file locks mean file storage, while HTTP PUTs and billions of objects mean object storage [9]. Uploads, data lake Parquet, backups and ML checkpoints all sit on the object side of his list [4], and none of them call seek(). Shared design files over SMB, build trees over NFS and enterprise home directories sit on the other side because they need directory browsing, file-level permissions and application transparency [16].

He also says most mature stacks run both side by side [5], which makes this a per-path decision rather than a per-company one. The lakehouse exception fits that reading: Iceberg and Delta are named as the niche where things do work over object storage [6], and that is a table format built for object semantics, not a database talked into them.

The hedge is a mount, and the writeup is careful about it. You can get filesystem semantics over S3-style storage, Carter says, but the mount layer will lie to you in small ways [13]. RustFS, whose documented feature table covers S3 core, versioning, bucket replication, event notifications and bitrot protection, ships no FUSE driver at all [14]. If your plan for the POSIX requirement you have not fully specified yet is "we will mount it", that plan depends on a component the server you picked may not offer.

This is one practitioner's checklist rather than a benchmark, and the only latency figures on offer are "sub-millisecond" and "millisecond-level" [3][6]. It is still enough, because the answer does not turn on how many milliseconds. It turns on whether anything in the path mutates bytes in place.

What to watch

  • Whether the cut-off project-by-project section of the post names any S3-compatible server that documents a supported FUSE driver, rather than omitting one.
  • Published latency or throughput figures for lakehouse table formats against POSIX filesystems, which would test the "niche exception" framing.
  • Any measured file count at which common filesystems actually degrade, instead of the round 10M in the anecdote.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence28
Adoption
Insufficient
Hype gap+18
Incentives34
Confidence40
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    The author says he has watched teams try to stretch a filesystem to 100M objects and that inode exhaustion is not a fun afternoon.

  2. [2]

    The post says terabyte-scale ML workloads are almost always object-storage-backed in 2026, covering training data, checkpoints, immutable dataset versions and Parquet feature stores queried via the S3 API.

  3. [3]

    The post's short answer: use file storage when you need POSIX semantics, which it defines as in-place edits, sub-millisecond random I/O and file locking (databases, OS files, NFS shares).

    ReportedSupportedView cited source

Sources

1 independent publisher whose own reporting we read for this story.

  1. dev.to

    1 article · August 23, 2026

    Object Storage vs File Storage: When to Use Which (2026)

Share your take

Let Clarity write the post for you.

Signed-in readers get a short post drafted on this story in the register they choose — narrative, analytical, or a direct position — editable to the last word before it goes anywhere. The share buttons at the top of this story work without an account.

Topics and entities

Follow any of these and your For You feed starts watching them — no settings page required.

Topics

Loading related stories