Curiosity
made runnable.
Every experiment here started with a question we couldn't let go of. Not a roadmap item. Not a client request. Just something worth finding out.
We don't experiment to ship. We experiment to know.
Most product organizations build what they know will work. We build what we're not sure about. That's a different kind of work — it requires more patience, more documentation, and a genuine comfort with outcomes that don't become features.
The experiments on this page are not prototypes waiting for funding. They're investigations. Some conclude cleanly. Some stall. Some reveal that the original question was the wrong one — which is its own kind of answer.
Sandboxed pipeline runner
securityIsolating untrusted automation pipelines inside ephemeral containers with enforced resource ceilings and syscall filtering. Safe execution without risking host integrity.
Zero-config service mesh
infraA local-first mesh layer that infers topology from running processes. No YAML manifests, no sidecars.
Structured log router
observabilityReal-time NDJSON log routing with field-level filtering, fan-out to multiple sinks, and zero-copy passthrough mode.
Static site integrity prober
reliabilityCrawls a deployed static site and checks asset hashes, link validity, CSP headers, and subresource integrity against a prior snapshot.
Compile-time env validator
dxTypeScript transformer that turns a .env.schema file into compile-time type errors. Missing or mistyped env vars fail the build, not the runtime.
Process memory tracer
perfLow-overhead tracing of allocations and frees across a process lifetime. Outputs flamegraphs compatible with speedscope.
Edge config propagation
distributedPushing config changes to distributed edge nodes with sub-second convergence using a gossip-adjacent protocol with conflict resolution based on logical clocks.
Typed migration runner
dataSchema migration framework that infers column types from application models and generates reversible, validated SQL with rollback checkpoints.
A question you can run is worth more than an opinion you can argue.
Code makes things falsifiable. That's the point of building instead of debating.
Boredom with the obvious is the only real prerequisite.
Every experiment here started because an existing solution felt wrong, incomplete, or interesting to pull apart.
Constraints are the creative material.
The tightest scope produces the sharpest thinking. An experiment with no limits is just a project without a plan.
Abandonment is a result, not a failure.
Knowing something doesn't work — and stopping because of that — is exactly how a good experiment should end.
Irritation
Something in our stack is annoying. Not broken — just wrong. That friction, repeated enough times, becomes a question worth answering.
Curiosity
Sometimes we just want to know if something is possible. No use case required. The answer itself is the deliverable.
Doubt
A convention we've been following without fully questioning. Running an experiment is the only honest way to find out if it deserves the trust we've given it.
Some of these experiments will quietly become tools. Most won't. All of them will have taught us something about the systems we operate, the assumptions we carry, and the questions that are actually worth asking.
That's enough of a reason to keep running them.