Enterprise-grade depth without the “upload your entire repo” shortcut. Every workspace ships with the full security stack active: safety is never optional.
We built Patcherly around one constraint: a breach of our systems must never compromise your code. The rest follows from there.
Your source files never move to our infrastructure. Your pre-apply backups stay on your machine and never reach Patcherly. The AI sees only what it strictly needs to draft a fix — nothing more. Every constraint below is a consequence of that one.
These aren’t settings. They’re commitments — encoded in the architecture.
Your codebase never lives on Patcherly servers. We don’t mirror, clone or warehouse it.
The connector authenticates with short-lived OAuth tokens scoped to your environment, never your repository or server credentials.
No cloud copy of your tree. Files stay where you put them.
Models receive a scrubbed error context, not your codebase.
Snapshots taken before a patch live on your host, full stop.
Patcherly staff have no production credentials to your servers.
We can’t access what isn’t on our infrastructure.
Inference only. Your data is never used to fine-tune third-party foundation models.
Each control is active for every workspace from the moment you connect a target. No paid add-ons needed.
Connectors authenticate via OAuth 2.0 Device Authorization Grant with short-lived access tokens, refresh-token rotation, and per-target HMAC-signed requests with timestamps and replay protection. Each token is bound to a single workspace and target, so a leaked token cannot move sideways — only the right target talks to the right workspace.
Errors, suggested patches, and target paths are checked and sanitised before they travel or apply. Junk payloads, accidental secret exposure and unsafe edits are caught before they reach any downstream system.
Patcherly is not a hosted copy of your repository. The connector sends only the error context required for analysis — never the full source tree. Sensitive values (API keys, passwords, tokens) are auto-redacted before any data reaches a model or log.
Before a fix touches a file, the connector creates a pre-apply snapshot on your host inside a backup folder protected from public web access (deny-all rules for Apache/Nginx, restrictive Unix permissions). Each snapshot ships with a sha256 manifest so rollback can verify integrity. Backups stay on your machine — we never warehouse your source tree.
Each workspace’s data is isolated at the database level. APIs are rate-limited so one noisy workspace can’t affect others; login throttling with exponential backoff blocks credential-stuffing attempts before they gain traction.
Modern TLS protects all browser and connector traffic. Strict transport policies and content security headers prevent interception, downgrade attacks and session-level vulnerabilities.
CSP, frame controls and hardened browser headers neutralise XSS, clickjacking and common account-takeover patterns. Sessions follow current best practice — short-lived tokens, secure flags, no client-side secret storage. MFA protects your account from unauthorized access.
Suspicious probing and abuse patterns trigger automated blocks and audit-friendly logging. AI prompt-injection attempts are detected and quarantined before a fix can ship — repeated attempts pause the target in protection mode. Drive-by scanners and bulk credential attacks hit a wall, not your workspace.
Error logs can turn into attacker-controlled text. A hostile site can try to slip instructions into a stack trace and steer the AI toward a dangerous patch. Patcherly treats that as a first-class threat.
Before any fix is suggested or applied, inbound context passes through dedicated detection and review gates. Suspicious analyses are quarantined for human review, flagged patches can’t be approved or applied, and repeated attempts put the target into a temporary safe-mode pause. Default-on for every workspace, on every plan.
Plain-language map of what we hold, what we don’t, and the legal references that back every line.
Patcherly uses third-party AI providers for inference only — to draft a fix from a scrubbed error context. Your code, backups and error payloads are never used to train third-party foundation models (see Terms §2.5 and Privacy Policy — Analysis and AI). Subprocessors are listed at /legal/subprocessors.
| What | Where / How | Legal reference |
|---|---|---|
| Account data & metadata | Account/profile data and operational error/fix data are stored separately; operational records use pseudonymous technical identifiers (no email or name in that store). Core application and operational databases run on EU (Frankfurt) infrastructure; some subprocessors process limited data outside the EEA with safeguards (Standard Contractual Clauses and similar). | Privacy — account & profile Privacy — operational data Privacy §5 (transfers) Privacy §7 (separation) Subprocessors (locations) DPA §3 |
| Source code & full repository | We do not ask you to upload your full codebase; we do not mirror your repository on Patcherly. Limited code or file excerpts may be sent only for error analysis when the connector transmits them as Service Data. | Privacy — what we do not collect Subprocessors — detection DPA §3 |
| Error payloads & log context | Official connectors apply best-effort pattern redaction to file/code excerpts and to log lines and tracebacks before they leave your environment. That catches many common secret shapes but cannot cover every format — never log secrets; anyone with access to the server or log files (including hosting staff) could otherwise read them. | Privacy — Analysis and AI Privacy — Secrets and logging Subprocessors — Data used for AI |
| Pre-apply file backups (connector) | Snapshots taken immediately before a patch are created by the connector on your environment, written into a backup folder protected from public web access (Apache/Nginx deny-all, restrictive Unix permissions on Linux/macOS) with a sha256 manifest, and are never warehoused on Patcherly infrastructure. Retention is indefinite and customer-managed — they stay on disk until you delete them. | Subprocessors — on-target backups |
| Patcherly application database backups | Separate from connector pre-apply backups. Patcherly takes its own DR backups of its application/operational databases (account data, error metadata, fix history). These are encrypted at rest and in transit, isolated from the live application, and pruned on a Patcherly-controlled schedule. They never contain your source tree or your connector pre-apply backups. | Privacy §7 (security) Privacy §6 (DR backup residue) |
| AI inference | Third-party AI providers receive only the error context needed to generate an analysis or patch. Service Data is not used to train or fine-tune third-party foundation models; per-organisation patch outcomes may be recorded inside Patcherly only. | Terms §2.5 Privacy — Analysis and AI Subprocessors — Data used for AI |
| Data Processing Agreement | Contractual processor terms (GDPR Art. 28) accepted with the Terms of Service. | DPA §1 (roles) DPA §2 (instructions) |
| Subprocessors | Published list of providers, purposes, data categories and regional notes. | Subprocessors (table) DPA §5 |
| Account deletion & export | Self-serve Download my data and Delete my account in the dashboard; deletion queues hard deletion from the primary application database within up to seven business days (longer if law or an active subscription period requires). After that, encrypted disaster-recovery backups of Patcherly’s own application databases may still contain residual rows until they age out (Privacy §4) — these are not your connector pre-apply file backups, which never leave your infrastructure. The operational data store may retain flagged error/analysis records and pseudonymous metrics as described in Privacy §6. | Privacy §6 (rights & deletion) DPA §9 DPA §7 |
Already using Patcherly? Security guides in the Help Center
Email [email protected] with [SECURITY] in the subject. We acknowledge within 24 hours and follow coordinated disclosure. Our security.txt lives at /.well-known/security.txt.
Last updated: July 2026. Material changes are announced in our changelog and to the responsible disclosure list.
Patcherly is in private beta and we’re onboarding teams personally. If the privacy and security model fits your team, the next step is the waitlist.