A real Apache Iceberg lakehouse, running on Myota Cyberstorage.

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.

RANSOM IMMUNITY · INSTANT REWIND · RESILIENCY WITHOUT REDUNDANCY
Explore the live lake
Now exploring — —
—
GitHub events in the lake
—
GitHub events / second
—
Shard buckets (3 data, 3 keys, 3 meta)

Cut storage infrastructure costs by 50% — and make the data ransom-immune and instantly recoverable while you do it.

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.

Myota Cyberstorage Classic S3
01

Security applied at write-time — before data reaches storage

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.

Ransom Immune
Classic S3

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.

02

Three-layer chained encryption

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.

Ransom Immune
Classic S3

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.

03

Cryptographic isolation across every location

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.

Ransom Immune
Classic S3

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.

04

Event capture intrinsic to the data — no control plane

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.

Instant Rewind
Classic S3

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.

05

Patented combination of erasure coding and Shamir Secret Sharing

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.

Ransom ImmuneInstant Rewind50% cost
Classic S3

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.

06

Quorum-based reconstruction with parallel paths

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.

Instant RewindAvailable Through Any Outage
Classic S3

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.

07

Immutable by architecture — not by policy

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.

Ransom Immune50% cost
Classic S3

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.

0.0 GitHub events / second into the lake ingest window
—
Trending repositories
Event types
Top languages
Bots vs humans
Human Bot
Inspect a raw event Myota a real event document straight out of the lake
—
—
Average fare
—
Average tip
—
Average distance
—
Total trips
Pickups by hour of day
Fare distribution
Tip % by payment type
Top pickup zones

What "resiliency without redundancy" looks like physically

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.

Expand and contract to fit your topology

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.

See it in 45 secondsMyota the Shard and Spread™ story
logical object hash  —
sharding scheme  —
The nine shard bucketsMyota one share per bucket

Content shares

Key shares

Meta shares

Same object, three different ciphertextsMyota read live off the shards
These three hex strings are the first 32 bytes of ciphertext that each content bucket holds for the same logical object. They are different. That difference is the encryption plus secret sharing, captured live: no single fragment reveals the data, and any two of the three rebuild it.
Iceberg time travel and instant rewind

Each 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.

Viewing snapshot: —
TableSnapshot IDTimestamp (UTC)
How this lake is actually builtMyota the real pipeline
Architecture diagram: GH Archive and NYC TLC taxi data feed an EventBridge-triggered Lambda running PyIceberg, which writes Apache Iceberg tables to the Myota Cortex S3 endpoint. Cortex applies Shard and Spread across nine independent shard buckets (three content, three key, three meta). Published Parquet and Iceberg are mirrored to S3, fronted by CloudFront, and served to users at seclake.myota.rfc1122.com.
An hourly EventBridge rule triggers the seclake-hourly-ingest Lambda, which uses PyIceberg to append GitHub and NYC taxi data to Apache Iceberg tables. Those writes land on the Myota Cortex S3 endpoint, where Shard and Spread™ encrypts each object and splits it across nine independent shard buckets, three content, three key, three meta. The published Parquet and Iceberg files are mirrored to S3, fronted by CloudFront, and served to you here. Every byte on this lake is protected the instant it is written.

Real SQL over the real Parquet files, in your browser

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.

DuckDB-WASM files: 'github_events.parquet' · 'nyc_taxi.parquet'
Loading DuckDB-WASM…