Case studies

Storage engineering, proven under failure.

We write kernel modules, consensus protocols and parallel filesystems, and nothing is considered done until it has survived the failures production will throw at it.

Proof sheet
20builds per release
OS × architecture matrix, native ARM runners, GPG-signed packages Evidence
6Mfiles per run
mdtest at 90% filesystem capacity, sized from cluster topology Evidence
6.12Linux kernel
Compatibility layer across VFS and memory-management API churn Evidence
2failures in a row
Mirrored metadata survives a second failure, mid-resync Evidence
TLA+model-checked
Protocol logic verified with TLC before it is written in C Evidence
15+dashboards
Production monitoring shipped with the filesystem, with alerting rules Evidence

Sources: evidence ledger, below. Numbers from our current client work.

Evidence ledger

Claims, with the work and the test behind them

We show our work so you don't have to take our word for it. This is what we built, how it was checked, and in which engagement, so your engineers can review it as they would a design.

ClaimWhat we builtHow it was checkedEngagement
Data survives a node failure mid-writeChunk-level replication, erasure coding and recovery for distributed block storagefio writes CRC32c-verified blocks, a storage node is killed mid-write, recovery runs, every checksum is re-validated in CINiova
HA metadata survives a second failureFixes for metadata-server crashes and buddy-resync failures in mirrored deploymentsStress run: baseline, kill primary, kill secondary mid-resync, re-run, compare before/after graphsBeeGFS / ThinkParQ
Upgrades without downtimeKernel compatibility shim through Linux 6.12, idmapped mounts, a parallel kernel module for two major versionsLive-upgrade scenario in the release test suite: both versions mount side by side, rollback is safeBeeGFS / ThinkParQ
Consensus holds under partitionRaft-replicated, RocksDB-backed metadata service with leader election and leasesProtocol logic model-checked with TLA+/TLC; partition scenarios encoded in multi-node system testsNiova
Releases that build everywhere20 OS × arch release builds on native ARM and x86 runners, GPG-signed packagesSupport matrix auto-discovered from upstream distro repositories, so it never goes staleBeeGFS / ThinkParQ
Performance measured at scaleIOR / mdtest pipelines up to 6M files at 90% capacity; IO500 automated end to endRuns in the same pipeline as fault injection, so throughput and recovery are measured togetherBeeGFS / ThinkParQ
Operable from day one15+ Grafana dashboards and installable alerting rules shipped with the productMetadata, client operations by node and user, and storage targets coveredBeeGFS / ThinkParQ
GPU data path validatedCI builds and tests against NVIDIA GPUDirect StorageAutomated DOCA compatibility matrix per distro and kernelBeeGFS / ThinkParQ

Method

Model it. Build it. Break it. Measure it.

The same four steps on every engagement, whether we're writing a storage engine or tuning a Lustre deployment. We spend the most time on the third step.

  1. Model

    Protocol-critical logic is specified and model-checked before it becomes C.

    TLA+ · TLC

  2. Build

    Kernel modules, storage engines and control planes in C, C++ and Go.

    io_uring · ublk · Raft

  3. Break

    Real multi-node clusters, exact faults injected while I/O is in flight.

    Ansible · pytest

  4. Measure

    Throughput and recovery measured in the same run, traced to the kernel function.

    IOR · IO500 · eBPF

How a typical stress run works
  1. Baselinefio + mdtest / IOR on a healthy cluster.
  2. Kill primaryPrimary node fails under load.
  3. Kill secondarySecond failure mid-resync.
  4. Re-runSame workload after recovery.
  5. CompareBefore/after graphs generated automatically.

Where it was proven

Two engagements, one standard

Niova

Distributed block storage, NVMe to Kubernetes

Built

  • Go CSI driver; block serving survives pod restarts
  • ublk kernel integration, shipped as DKMS
  • io_uring reactor with raw NVMe passthrough

Checked by

  • TLA+ model checking with TLC
  • Hundreds of parametrised failure scenarios
  • Checksums re-validated after a node kill

BeeGFS / ThinkParQ

Engineering partnership, development to production

Built

  • Metadata search index, built on GUFI
  • Kernel compatibility through Linux 6.12
  • 20 OS × arch release pipeline

Checked by

  • Double-failure stress runs
  • 9 VM targets plus a physical lab
  • Separate perf-regression pipeline

“We have had the pleasure of working closely with Manisha and the team at Paroscale Technologies for the past few months, going straight into forward development with very little time to adopt the development environment, as well as the code base for our parallel file system BeeGFS. The meticulous work that Paroscale has already provided, exceeded our expectations. It is a pleasure to have Paroscale as a partner.”

Frank Herold, CEO, ThinkParQ

Start here

Send us a benchmark run.

Topology, workload and one run is enough. An engineer replies with where the time is going and what we'd test first.