Rust · gRPC · HTTP Drop-in ticketing core for your product.

The headless ticketing API
you actually want to build on.

RustGrid is a developer-first ticketing backend: multi-tenant RBAC, HTTP + gRPC, idempotent write flows, and observability built in. Ship tickets, comments, projects and sprints without building Jira from scratch.

Multi-tenant by design Idempotent writes, ETags, and RBAC Ready for your frontend of choice
POST /api/v1/tickets
RustGrid · Live
// HTTP: create a ticket
POST /api/v1/projects/DEMO/tickets
Authorization: Bearer <token>
X-Tenant-Id: acme

{
  "title": "Customer cannot log in",
  "description": "Login fails with 500 after password reset.",
  "type": "bug",
  "priority": "high"
}

// Rust: query via gRPC
let mut client = TicketsClient::new(channel);
let resp = client
    .list_tickets(ListTicketsRequest {
        tenant_id: "acme".into(),
        project_key: "DEMO".into(),
        page: 1,
        size: 25,
        ..Default::default()
    })
    .await?;
Multi-tenant RBAC
HTTP + gRPC
Observability-first
WHY RUSTGRID

Ticketing as an API primitive, not an afterthought.

RustGrid gives you a hardened, opinionated ticketing core: tenants, projects, tickets, comments, memberships and roles — exposed as a clean HTTP and gRPC surface you can plug into any product.

Architecture

Built for multi-tenant SaaS from day one.

Tenants, projects, memberships and roles are first-class. Every request is tenant-scoped, with row-level RBAC and audit trails so you can safely host multiple customers on the same cluster.

Tenant isolation RBAC Audit-ready
Protocols

HTTP for the frontend, gRPC for the core.

Consume RustGrid from any frontend via REST, or speak gRPC directly from your services. The same domain model, two transport layers, one consistent contract.

Axum HTTP Tonic gRPC Typed contracts
Correctness

Idempotent by design, not by convention.

Built-in idempotency keys, ETags and guarded updates. RustGrid defends your write paths so your product can handle retries, timeouts and race conditions without duplicating tickets.

Idempotency keys ETag + If-Match Race-safe updates
Observability

Traces, metrics & logs wired in.

Structured logs, request IDs, per-query timings and Prometheus metrics. RustGrid is ready to plug into your dashboards and on-call rotation on day one.

Prometheus Tracing Slow query alerts
Security

JWT, roles & granular permissions.

Token-based auth with tenant-bound memberships and role-based permissions for tickets, projects and comments. Owners, agents, auditors and bots each get exactly what they need.

JWT Role mapping Least privilege
Future-proof

Made in Rust, ready for scale.

A modern Rust stack built on Axum, Tonic and SQLx. Memory-safe, async-first and engineered to survive real-world traffic spikes without falling over.

Rust PostgreSQL Horizontal friendly
ARCHITECTURE

A ticketing core that plugs into your stack, not the other way around.

RustGrid sits in your backend as a dedicated ticketing engine. Your product owns the UX — RustGrid takes care of tenants, queues, workflows and data integrity.

How it fits

Frontends talk to you. You talk to RustGrid.

Your React, Vue or native clients never have to know RustGrid exists. They hit your API, your auth, your brand — and your backend delegates ticketing concerns to RustGrid via HTTP or gRPC.

Headless ticketing core Keep your own auth gateway Composable with existing services
Your frontends Web · Mobile · Admin UI Your backend Auth · Billing · Domain logic RustGrid Ticketing core Tenants & projects Tickets & comments RBAC & memberships PostgreSQL · SQLx · Observability · Idempotency
FOR DEVELOPERS

Get tickets, comments and projects in a few lines of code.

RustGrid is API-first. Everything you can do in the UI can be done over HTTP or gRPC with typed contracts. Start with tickets, plug in projects, then layer on sprints and relations.

HTTP · JSON curl / fetch
# Create a ticket via HTTP
curl -X POST https://api.rustgrid.com/api/v1/projects/DEMO/tickets \
  -H "Authorization: Bearer <token>" \
  -H "X-Tenant-Id: acme" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Payments failing on Safari",
    "description": "Customer reports 3D Secure loop.",
    "type": "bug",
    "priority": "critical"
  }'

// List tickets from your frontend
const res = await fetch("/api/tickets?tenant=acme&project=DEMO");
const data = await res.json();
Rust · gRPC Tonic client
use rustgrid_proto::tickets::v1::{
    tickets_client::TicketsClient, ListTicketsRequest
};

async fn list_project_tickets() -> Result<(), Box<dyn std::error::Error>> {
    let channel = tonic::transport::Channel::from_static(
        "https://grpc.rustgrid.com",
    )
    .connect()
    .await?;

    let mut client = TicketsClient::new(channel);

    let resp = client
        .list_tickets(ListTicketsRequest {
            tenant_id: "acme".into(),
            project_key: "DEMO".into(),
            page: 1,
            size: 20,
            ..Default::default()
        })
        .await?;

    println!("tickets = {:?}", resp.into_inner().items);
    Ok(())
}
USE CASES

Where RustGrid quietly does the heavy lifting.

RustGrid is for teams who need serious ticketing and workflow primitives but don’t want to ship Yet Another SaaS silo. You keep your product; RustGrid powers the queues.

Customer support

Build support queues into your product.

Add a “Contact support” surface in your app that creates tickets in RustGrid. Let your agents work in a custom backoffice while customers see status updates, SLAs and comments right where they are.

Internal ops

Run your ops teams on the same engine.

Legal, finance, onboarding, trust & safety – model them all as projects and queues in RustGrid and orchestrate multi-tenant workflows without another SaaS contract.

Platforms

Offer white-label ticketing to your users.

If you’re a platform or marketplace, use RustGrid to give each customer their own space for tickets, projects and comments under your brand, domain and UX.

PRICING

Start free in beta. Pay when tickets matter.

During the private beta, RustGrid is free for early adopters. When we launch publicly, pricing will stay simple and usage-based — aligned with the value your product gets from reliable ticketing.

Developer-friendly from the first ticket.

No per-seat tax. No dark patterns. RustGrid will be priced on API usage and tenants, so you can prototype, test and ship without asking for a budget approval every time you add a teammate.

Beta
Free for early teams
Priority feedback channel.
Launch
Fair, usage-based
Priced on tenants & API calls.
Teams
Sane limits
Bring your stack and identity.
FAQ

Questions teams ask before wiring in RustGrid.

A few clarifications before you plug RustGrid into your stack. If you need something specific, use the waitlist form and mention your use case.

Is RustGrid a full UI product like Jira or Zendesk?
No. RustGrid is deliberately headless: it’s an API-first ticketing engine. You keep your own UI, authentication, billing and customer experience. RustGrid handles the mechanics of tickets, comments, projects, tenants and roles.
Which protocols and clients are supported?
RustGrid exposes both a REST/HTTP API and a gRPC API with generated stubs. You can integrate from any language that can speak HTTP or gRPC – Rust, TypeScript, Go, Python, Java and more.
How do multi-tenant and RBAC features work?
Every ticket, project and comment belongs to a tenant. Users join tenants via memberships, which are bound to roles with permissions. That lets you model owners, agents, auditors and automation users without sharing state between customers.
Can I run RustGrid on my own infrastructure?
The initial private beta focuses on a managed cloud offering. Self-hosting is on the roadmap for teams that need full control over their ticketing data and deployment environment.
What about password reset and email delivery?
RustGrid includes flows for login, password reset and email-based actions, designed to work with providers like Postmark or Mailgun. You keep your domain and email branding; RustGrid wires up the mechanics.
When will the public beta be available?
We’re working towards a public beta in 2026. Teams on the waitlist will get early access, direct input into the roadmap and migration help if they’re moving from an in-house ticketing system.
Be one of the first teams building on RustGrid.

Tell us a bit about your stack and use case and we’ll reach out with early access details when the private beta opens.

Email us for beta