build. change. fix.

Change production in seconds, not deploys.

Ship changes and fixes to your live app without waiting on a deploy. Bring your own source edit, or let AI draft one from a report your users filed in-page. Your team previews it on the real site and approves it, and it is live for every visitor, cryptographically signed, while a real pull request opens with the permanent change. When the PR merges, the patch retires itself.

Already have a workspace? Sign in to the dashboard

46 minutes

How long a one-line fix can take to clear a typical CI/CD pipeline¹ — Sarcio delivers an approved fix in seconds.

< 1 hour

DORA's bar for elite failed-deployment recovery; low performers take up to a week². Sarcio is the fast path to restore.

$2M / hour

Median cost of a high-impact production outage³. Every minute a known bug stays live is money.

How it works

From "it's broken" to "it's fixed" — one governed pipeline.

No war room, no emergency deploy, no SSH. One flow takes a bug from in-page report to a live, signed, reversible fix — with the permanent source fix already in flight.

1

Report in-page

Anyone — a QA engineer, a client, a support agent — flags the bug where it happens. Console, network, and screenshot context attach automatically.

2

AI drafts a scoped fix

Triage plus a minimal, constrained patch with a hard expiry — and no risk rating, because that call is your reviewer’s. The AI drafts; it never ships.

3

Preview in isolation

See the fix applied for you alone before anyone else does. The broken behavior keeps failing for everyone until you say otherwise.

4

Approve — twice, if risky

A human signs off on every patch. Elevated-risk changes require two distinct approvers before anything is signed.

5

Live in seconds

The signed patch pushes to every visitor over WebSocket — no redeploy. Retire it any time with one click.

6

The PR opens itself

A pull request with the permanent source fix opens on GitHub, GitLab, or Bitbucket, carrying a sarcio/approval check. When it merges, the patch auto-retires.

Review fixes from your AI assistant

Triage reports, check what a drafted patch changes, and see what is live from Claude or any Model Context Protocol (MCP) client. Approval stays with a signed-in person in the dashboard. Set up the Sarcio MCP server →

No patch debt

Every patch is a bridge to a merged pull request.

The classic objection to hotfixing is drift: quick fixes that outlive everyone's memory. Sarcio is designed so a patch cannot silently outlive its fix.

Right now

A temporary, signed, time-boxed patch

  • Live for every visitor seconds after approval
  • Hard TTL with client-side expiry rollback
  • One-click retire reverts the site live
  • Expiry reminders before anything lapses
Already in flight

The permanent fix, as a real PR

  • Opened automatically on your Git host with the source fix
  • Merge it — the patch retires itself
  • PR closed or stalled? The patch is flagged as orphaned
  • A Jira ticket filed, updated, and moved to Done when the fix merges, if you choose
Three patch kinds

One signed pipeline, covering your whole stack.

DOM

Visual & markup bugs

Constrained DOM operations — never arbitrary JavaScript — applied by a ~19KB (gzipped) widget in the browser. Perfect for the hidden required field, the broken banner, the unclickable button.
Server

API & backend bugs

Declarative request/response rules — default a field, set a header, skip a validation, reshape a response, gate a route — enforced by a self-hosted sidecar behind Node, PHP or Java, or, where a host cannot run one, by the PHP library or the WordPress plugin itself. If anything is wrong, your app runs its normal code.
Module

Real logic bugs

Replacement code for exactly the modules a source fix touches, live without a deploy — in the browser, in web workers, and across Node clusters with a canary rollout.
Works with your stack

Frontend to backend, four languages deep.

One protocol, one signing scheme, verified identically everywhere — so an approved fix lands on every tier of your stack at once. See all integrations →

Browser & build

React

Angular

Vanilla JS

Web Workers

Vite

webpack

Server

Node.js

Express

Fastify

Koa

Hono

PHP

Laravel

Symfony

WordPress

Java

Spring Boot

Servlet

Delivery & workflow

GitHub

GitLab

Bitbucket

Jira

Kubernetes

Docker

Your own CI

Who it's for

Built for the teams who own the worst day.

WordPress owners and agencies

A client's site breaks after a plugin update: the report button replaces the panicked phone call, and the fix is waiting in wp-admin, where a kept fix stays for good. Everything else they ask for, a new phone number or a product on sale, the assistant changes once you have seen it on a preview of the site. One account covers every client site, and Recent changes is the report you hand them.

E-commerce

A checkout bug during a code freeze is measurable lost revenue. Constrained, reversible, audited ops are a freeze-safe break-glass path — with the paper trail your change board wants.

Platform & SRE

Your deploys are safe but slow, and MTTR is your KPI. Patch the symptom in seconds, canary it on real traffic in Node clusters, and let the permanent fix ride the pipeline at its own pace.

Small product teams

No dedicated SRE — the person fixing prod is also building the roadmap. Reports arrive with full context instead of vague screenshots, and the AI drafts the diff you were going to write anyway.
Security

More controlled than a panic deploy.

Patching production is only scary when it's ungoverned. Sarcio is the governed version — built to hand to your security reviewer. Read the full security model →

Ed25519-signed manifests — verified in the client against your workspace's own key before anything applies

Constrained operations — hard deny-rules enforced server-side; never arbitrary code

Two-approver gate — for elevated-risk patches, with preview-before-live for every change

Self-hosted server tier — outbound-only sidecar, no inbound credentials, safe when it is down

Append-only audit log — every sign-in, approval, rotation, and retirement — exportable as CSV/JSON

RBAC, TOTP 2FA, OAuth sign-in — plus scoped API tokens over a default-deny surface

Per-tenant keys — envelope-encrypted at rest — a leaked credential is scoped to one workspace

Builds in your own CI — module patches can build in your pipeline, never on Sarcio’s build servers

FAQ

The questions your reviewers will ask.

Sarcio is a governed break-glass path, not a cowboy console. Patches are constrained operations — never arbitrary code — validated server-side, previewed in isolation, approved by a human (two approvers for risky changes), signed, time-boxed with a hard expiry, reversible in one click, and recorded on an append-only audit log.

Every patch is verified in the client against your workspace's own Ed25519 signing key before anything is applied. Even a fully compromised delivery channel cannot push an unsigned payload to your users. The server tier verifies in a sidecar you host yourself, with outbound-only connections, or on WordPress inside the plugin, and fails closed either way.

Every patch ships with the pull request that makes it permanent. When the PR merges, the patch retires automatically. Patches carry hard expiries with reminder emails, live patches sit on one dashboard, and a patch whose PR was closed or stalled is flagged as orphaned — a patch cannot silently outlive its fix.

The AI only drafts. A human previews every patch in isolation and approves it before it goes live, and risky changes require two distinct approvers. DOM and server patches are constrained operations validated server-side — the AI cannot emit arbitrary code into them. Module patches are built from your repository and reviewed like any code change.

Sarcio is built for review: per-tenant signing keys, role-based access control, TOTP two-factor authentication, OAuth sign-in, admin-only integrations that act as a bot or app rather than a person, envelope encryption at rest, scoped API tokens, an exportable append-only audit trail, Jira change tickets, and module builds that can run in your own CI instead of on Sarcio’s infrastructure.

Plans differ by size, not by capability: every plan ships all three patch kinds, every connector, and every security control. What scales is how many sites and members a workspace covers (1 site and 1 seat on Solo, 5 and 10 on Team, 25 and 50 on Scale) and its monthly AI allowance: 80 AI credits on Solo, 400 on Team and 2,000 on Scale, enough for up to 40, 200 and 1,000 AI-drafted fixes. Captured reports are kept for 30 days on Solo, 90 on Team and 365 on Scale, and each report’s screenshot is stored at up to 2 MiB on Solo and Team and 5 MiB on Scale. Credits measure the model work itself, so every AI call spends them, including pull request writing and failed attempts. Exceeding either allowance never blocks a report: drafting pauses for the rest of the month and reports wait for manual triage. The one place size shows through is the two-approver rule on elevated-risk changes: two different people must approve, so shipping those needs at least two seats. The reviewer who approves first rates each patch low or elevated, and only an elevated rating calls for that second approver. WordPress sites have their own plans, priced on sites rather than seats: WordPress for one site, Freelancer for three, Agency for ten and Agency Plus for fifty.

Yes. A workspace admin cancels from Settings → Plan & billing in the dashboard; you keep access until the end of the period you've paid for. You can change plan there too: upgrades charge the prorated difference and apply once paid, downgrades apply right away with the unused time credited to your next invoice.

Stripe retries the charge and your admins are emailed, and everything keeps working. If it is still unpaid after 14 days the workspace is locked: nobody can sign in until it is paid, and admins get a link to pay without signing in. Live patches on your sites keep running while locked. After 30 days unpaid the subscription is canceled.

No. Pull requests, checks and tickets come from a workspace connection that only admins set up, ideally the Sarcio GitHub App or a bot token, so nothing depends on one person. Members can link their own GitHub, GitLab, Bitbucket or Jira account so fix PRs and tickets name or @mention them; a link stores no token. An admin can also allow acting links, which are off by default: then a member can opt in so Sarcio approves the fix PR and posts the Jira go-live comment as them. Approval itself always happens in Sarcio, and nothing done on a Git host counts toward it.

The browser widget is a small self-contained script of about 19KB gzipped that loads asynchronously and never blocks rendering. Heavier capture features like screenshots are lazy-loaded only when a report is actually filed.

The next change to production doesn't need a deploy.

Create a workspace, drop the widget on a site, and take your first change or report to a live, signed patch, with the permanent PR already open.

Create a workspace
Sources: ¹ Dunelm Engineering, "How we cut CI/CD pipeline time by 66%" — a representative one-line fix took ~46 minutes end to end. ² DORA (DevOps Research & Assessment) — elite performers restore service in under an hour; low performers take up to a week. ³ New Relic, 2025 Observability Forecast — median cost of a high-impact outage of ~$2M per hour.