External services

An external service is something your application depends on that Kuppit does not provision: a payment processor, a model API, an email sender, an error tracker, an internal API of your own. Kuppit creates nothing for it and manages nothing about it. It is part of the architecture, so it is drawn on the project's Overview — outside every environment, with an edge from each service that uses it — and it is where the variable names those services read for it are kept in view.

What Kuppit detects

When Kuppit analyses a repository it looks for the services the code uses, from the names it finds and nothing else:

Kuppit never reads the value of a variable, in your code or in an example file. A key pasted into .env.example is recognised by the name beside it and never stored.

The services Kuppit recognises today are Stripe, OpenAI, Anthropic, Resend, Sentry, Clerk and Supabase. Anything else is added by hand.

Each finding is weighed. A package on its own is worth a look and is marked Review; a variable name on its own is not enough to mention; the two together are a service in use. The list says how sure Kuppit is — Detected · likely, very confident, possible — and Why? opens every piece of evidence behind it.

When you create a project

The New project page lists what it found under External services detected, beside the resources it proposes. A service Kuppit is sure of starts checked; one worth a look starts unchecked, marked Review. Checked services are drawn on the graph from the moment the project exists.

Unchecked is a decision: the service is ignored, and Kuppit does not suggest it again. An ignored service can be brought back from the Overview (below).

On the Overview

Beside each environment that uses anything outside Kuppit stands one External services card: how many, and either Configured or how many of them need configuration in that environment. A dotted line runs to it from every service in the environment that uses something, with no label — the line is the relationship, and the card says how many. Open the card with its chevron and the services stand behind it, one short card each: the External chip beside its name, then the kind of service and who uses it there. Each environment opens and closes on its own, and the picture makes room for what is open; nothing about it is remembered between visits. The same service stands behind every environment that uses it, while Kuppit still holds it once. Select the group, a service, or a line, to open the panel.

The group's panel lists every service in that environment with a check or how many names it is missing; a row opens the service, seen from that environment, and Add external service and Detect external services are there too. A service's panel shows what it is, who uses it in that environment, its Required variables each with a check or Missing, Set on — each service with a link to its Variables — Why Kuppit detected it, when it was last detected and at which commit, and where else in the project it is used. Open leads to the service's site. Its menu, on a right-click or behind the ellipsis, offers Open service and Ignore for a detected service; Edit… and Delete external service for one you added.

A line from a service to the group names the services it uses and leads to the group; a line from the group to a service names the Required variables. Neither is a connection: they summarise bindings and can be changed nowhere. Kuppit reads the names, never the values.

On a phone, each environment lists External services beneath its cards, opening onto them.

Services waiting for a decision

When Kuppit has found a service nobody has decided about, a line above the picture says so — An external service was detected in the repository: Resend — with Review. The panel then lists each one with Add to graph and Ignore, and, under Ignored, the services you have ignored before, each with Add to graph to restore it.

Detecting again

Right-click empty canvas and choose Detect external services. Kuppit reads the production branch's head again, exactly as it does for a new project, and records what it finds beside what it already knew. A decision you have made is kept: a confirmed service stays confirmed, an ignored one stays ignored, and only a service that is new to the project is suggested. Variable names already configured on your production services count as evidence too — a service you set STRIPE_SECRET_KEY on by hand is a service that uses Stripe.

Detection follows your deployments

Every deployment's source is read the same way, for the service that deployed. What it shows is recorded beside what the project knew: a service the code began using is suggested, a service that component stopped referencing is unbound from it — the service stays, with whatever else still uses it, and a decision about it is kept — and the project's Activity says which: web uses Resend as of a1b2c3d, worker no longer references Stripe as of a1b2c3d.

Detection runs when you create a project, on every deployment, and when you ask for it. It never holds a deployment up and never fails one.

Configuration

Once a service is on the graph, Kuppit compares what each component reads for it against what each environment has set. The names come from the code — STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET — and each environment's copy of the component either has each name, as its own variable or one inherited from the environment, or does not. Kuppit reads the names, never the values.

A name an environment has not set is Missing. That environment's External services card says how many services need configuration, the line from the group to the service turns amber, as a line into Production does, and is labelled with how many — 1 missing — and the service's panel lists every name with a check or Missing, beside the link to the service's Variables where it is set:

Staging · web                    Variables →
  STRIPE_SECRET_KEY       ✓
  STRIPE_WEBHOOK_SECRET   Missing

Set the variable and the warning goes; nothing is redeployed for it, and the running deployment is unchanged until the next one, as with any variable change.

Services you add yourself

Right-click empty canvas and choose Add external service… for anything Kuppit cannot detect: an internal API, a vendor it does not know. Give it a Name, a Kind, optionally a URL for Open to lead to, and tick the components under Used by that depend on it. It is drawn at once, with the same card and the same edges as a detected one. Edit… changes any of that later; Delete external service removes it from the graph and changes nothing that runs.

What an external service is not

It has no status, no deployments, no logs and no variables of its own. It cannot be connected to, copied into an environment or deleted with one. The application graph draws it so that the whole architecture is in one picture; what runs is still exactly the resources inside the environments.

The project's Activity records each decision — a service added to the graph, ignored, added by hand or removed — and each change a deployment revealed.