Every byte is encrypted at write time and split into nine shards across separate buckets: three for the data, three for its keys, three for its metadata. No single bucket holds a reconstructable copy, and any one can fail without taking the lake down. Ransom immunity by architecture. The data is real public data, refreshed hourly, not staged.
This lake runs on Myota Cyberstorage. Below: the seven patented architectural properties that produce ransom immunity, instant rewind, data access through any outage, and the cost cut — each set against how classic S3 behaves on the same point. These are not features. They are properties of the Shard and Spread™ math.
The first time data touches any storage destination, it is already encrypted and sharded. There is no window where complete, unprotected data exists anywhere in the architecture. Security is intrinsic to the data — not applied around it after the fact.
Encryption is applied by the platform after the object arrives. Whoever holds the key — or a credential that can call it — can read or re-encrypt the whole object.
AES-256 client-side encryption (only the customer holds the key) → key material sharded via Shamir Secret Sharing across independent locations (no KMS, no vault, no HSM) → below quorum, reconstruction is information-theoretically impossible regardless of computing power. Each layer must be defeated independently and simultaneously.
A single managed key (SSE-S3 or one KMS key) protects the object. Compromise that one key path and every object it covers is readable in full.
Each shard is cryptographically separated from every other. Each storage bucket carries its own independent key and access token. Compromising one location — regardless of credentials used — yields fragments with zero standalone value and zero information about what any other shard contains.
A stolen IAM key exposes whole objects in the bucket it can reach. On Myota the same stolen credential yields one meaningless fragment, below quorum, that reveals nothing about any other shard.
Every create, update, and delete event is captured and recorded within the data architecture itself — not in a separate database or management system. There is no control plane to attack, no catalog to destroy, no metadata index to erase. Reconstruction requires only the fragments — nothing else.
Versioning and history live in bucket configuration and external catalogs. Disable versioning or delete the catalog with a privileged call and the recovery trail goes with it.
Erasure coding distributes data across shards so any sufficient subset reconstructs the whole. Shamir Secret Sharing applies the same principle to key material. Together: no single complete copy is ever stored anywhere — not one. No full copy needed for reconstruction. No full copy available to an attacker.
Durability comes from keeping multiple full copies of every object. Myota reaches the same tolerance with erasure coding plus Shamir Secret Sharing and no full copy anywhere — which is where the 50% infrastructure cost cut comes from.
Reconstruction requires only a quorum of shards — not all of them. Any location can fail, be unavailable, or be compromised and reconstruction proceeds automatically from the remainder across multiple parallel paths simultaneously. No orchestration. No workflow. No dependency on any single provider.
Availability is tied to one provider and region. If that account or region is unreachable, so is the object — there is no quorum of independent locations to rebuild from.
Immutability is a mathematical property of the fragment set — not a retention lock an administrator sets. No privileged credential can override it. No administrative action makes a fragment set usable below quorum. Policy-based immutability holds until a privileged account is compromised. Mathematical immutability holds unconditionally.
Object Lock is a retention policy. A sufficiently privileged compromise can work around it — the Codefinger pattern re-encrypts buckets using S3's own features once an IAM key is stolen. Myota's immutability is mathematical, with no privileged override.
a real event document straight out of the lake
—
One logical object is encrypted with AES-256 at write time, then split by Shard and Spread™ into fragments. The data, its metadata, and the keys are all split and spread across separate buckets, so no single bucket holds a usable copy of anything: a stolen credential at one location yields fragments with no standalone value. Reassembling the data requires meeting the reconstruction threshold across independent locations at once, each with its own credentials; below that threshold it is mathematically impossible. That threshold is the owner's recovery path, not an attacker's, and it is why any one bucket can fail without taking the lake down. That is resiliency without redundancy: protection without keeping extra full copies.
The number of shard buckets and where they live are configurable, not fixed. Tune the count to the resiliency you need, and place the buckets to meet your co-location and data-sovereignty requirements: on-premises, hybrid cloud, or across multiple clouds. This live lab runs nine buckets on independent object storage (three content, three key, three meta; any two of three per group). A typical production deployment uses four buckets, each carrying a content, key, and meta share, with any two of four recovering. Same Shard and Spread™ architecture, sized to the deployment.
the Shard and Spread™ story
one share per bucket
read live off the shardsEach ingest is an Apache Iceberg snapshot. Iceberg time travel plus Myota instant rewind together mean you can read the lake exactly as it stood at any past snapshot, and recover to that point if anything tampers with the storage underneath.
| Table | Snapshot ID | Timestamp (UTC) |
|---|
the real pipeline
This runs entirely client-side with DuckDB-WASM, reading the same Parquet files that mirror the live lake. No server, no login. Edit the SQL and run it.