quark · developers
A platform you can drive, not just click.
The console is the easy way in. Everything it does — every sandbox, route, index, and quota — is an API call with the same shape, the same auth, and the same rules. There is no hidden second interface where the real platform lives.
one interface
One consistent API surface.
Quark's services are defined by versioned, strongly-typed contracts — the same contracts that generate the SDKs you use. That consistency shows up as conventions you learn once and apply everywhere.
Everything from an index to a sandbox run is an addressable resource in a project, with labels you can attach and read.
Mutations accept an idempotency key, so a flaky connection can't launch two runs.
Updates carry an etag, so two writers can't silently stomp each other.
Anything that takes real time — indexing, rebuilding, batch runs — returns an operation you can poll or stream progress from, with structured, retryable errors when something fails.
Lists and watches stream rather than paginate, and long-running work reports progress as it happens.
for your team
The learning curve is one learning curve, not one per service.
automation
Script the whole platform.
Drive routes, sandboxes, workflows, and indexes from scripts and CI with the platform's own command line.
Generated, typed clients that stay in lockstep with the services — because they come from the same source.
Step graphs are declarative and versioned: define the pipeline, publish the version, trigger runs with input — and the executor checkpoints its way through.
A run is addressable and inspectable — input, output, status — from the same API that launched it. Nothing lives only in a console pane.
local-first
Local-first, then hosted when you're ready.
The console connects to a platform by handing it an endpoint map, a key, and a project — nothing more. That same handshake works against a hosted deployment, your team's hardware, or a platform running entirely on your own.
Build against your own deployment, wire your tests against it, then promote the identical declarations to a shared one. No environment drift, no “works only in staging” folklore.
beyond the console
Observability lives in the foundation.
Requests carry their tenant, the resource, and the request's identity across service boundaries — so “what happened here” has a trace, not a theory.
Every service exposes readiness, health, and metrics in familiar shapes.
Secret operations and sensitive actions are recorded in order, readable from the console.
Every run is recorded with input, output, and status — the answer to “why did that happen” is a lookup, not a dig through logs.
extension
Built to be extended, not just consumed.
New capability domains land as products that speak the same contracts, and the console picks them up automatically when a deployment enables them.
Bring-your-own capacity joins the platform and starts hosting workloads without forking it. The extension points you'd need are the ones the platform already uses.
contact
Talk to us about running Quark.
Tell us about your workloads — we will show you what your own cloud can do.