Proxy
Menu

Platform

Six stages. Eight services. One record.

Proxy covers the lifecycle around getting work completed: something arrives, it is understood, it is kept, people are scheduled, the work is done, and all of it can be shown afterwards. The services are separate. The conventions underneath them are not.

Stages
Capture, Process, Store, Coordinate, Execute, Prove
Services
Eight, each with its own API and meter
Shared
Credentials, authorisation, audit, metering, conventions

The stages are a model, not a menu.

A stage describes what is happening to the work. A service is the thing you buy and call. The two do not map one to one, and pretending they did would make the catalogue easier to draw and harder to use.

Choose a lifecycle stage

Something arrives

Files, forms and messages enter from wherever the work starts.

Your page mounts a Proxy component with a short-lived token your own backend minted. The limits shown to the person are the limits Proxy enforces, because both are read off that token rather than out of page code.

  • Browser uploads through a single-capability client session
  • Forms completed and submitted against a resource you name
  • Inbound email and SMS recorded against the same record
  • Addresses resolved at the point of entry, before bad data lands

Delivered by

Storage Communications Address Lookup

Evidence it leaves

A stored object with the actor, the resource and the byte count.

It is understood

Text extraction, classification and checks turn a file into fields.

Processing is asynchronous and metered per page or per document. You get a job you can poll or a webhook you can trust, and the same operation key appears on the usage record you are billed for.

  • Optical character recognition, per page or per document
  • Classification of what the document is
  • Extraction of the fields you asked for
  • Identity and document verification where the work needs it

Delivered by

Processor Identity

Evidence it leaves

A job with a terminal state, and one usage record per unit processed.

It is kept properly

Managed objects with storage class, metadata and a size ledger.

Objects belong to an organisation, not to a bucket you have to secure. Storage class is explicit, from standard through to deep archive, and every size change is a ledger event rather than a recalculated total.

  • Six storage classes, from standard to deep archive
  • Metadata you define, queryable alongside ours
  • A size ledger, so a bill can be explained after the fact
  • Deletion that stays reversible until it does not

Delivered by

Storage

Evidence it leaves

A ledger entry for every size and lifecycle event on the object.

People are scheduled

Availability, appointments and bookings against real constraints.

Booking is the stage where your customer and your team meet, so it runs in the browser on a token scoped to one booking, and the appointment it creates is attached to the record the work already lives on.

  • Availability published from the constraints you set
  • Appointments booked by the customer, in your page
  • Bookings attached to the record, not to a calendar silo
  • Changes and cancellations recorded rather than overwritten

Delivered by

Calendar

Evidence it leaves

A booking event with who booked it, when, and against what.

The work is done

Documents generated, signatures captured, messages sent.

This is the stage that leaves your organisation. An envelope puts a document in front of somebody outside the business over your name, so it is enabled deliberately rather than switched on by default.

  • Documents generated from your templates
  • Signature envelopes through draft, sent, opened, viewed, signed, completed
  • Drawn and typed signatures, validated server-side
  • Email and SMS sent on the organisation's behalf

Delivered by

Documents Sign Communications

Evidence it leaves

An envelope status history and a delivery record per message.

It can be shown

Every operation above leaves a record you can hand to somebody else.

Prove is not a service you buy. It is what the other five stages produce as they run: a named actor on every mutation, a usage record with the operation and the unit, a delivery outcome, and a signature verdict.

  • A named actor on every mutating operation
  • Usage records carrying the operation key, quantity and unit
  • Webhook events with a delivery status, retried and recorded
  • Signature validation verdicts kept with the signature

Delivered by

The platform itself

Evidence it leaves

The audit trail, the usage ledger and the delivery record.

Eight services that behave like one platform.

Independence is the point, but independence with six different opinions about authentication would be worse than a suite. These are the six things every service does the same way.

One credential model

A publishable key for the browser, a secret key for your server, and short-lived client sessions your backend mints for a single capability.

Three types, one prefix convention, and the environment in the prefix.

One authorisation model

The same policies serve the API and the web interface. A permission written for a person is the permission an integration inherits, narrowed by its scopes.

There is no second authorisation system to keep in step with the first.

One organisation, resolved for you

The credential decides the organisation, the environment and the enabled services. There is no organisation id to send and no header to set.

A cross-organisation identifier is refused during route resolution.

One meter, read per service

Every operation writes a usage record carrying its operation key, quantity, billing unit and cost, so "what did Processor cost this month" is a query rather than an allocation exercise.

Free operations are recorded in full, because the count still matters.

One set of wire conventions

A versioned path, responses under a data key, stable error codes, idempotency keys on anything that costs money, and rate limits applied per credential and per organisation.

Additive changes ship inside v1. Breaking ones get a new version.

One audit trail

Every mutating operation has a named actor, and that actor is written to the trail and onto the record. Services do not keep separate histories that have to be reconciled.

The actor is required, not derived, and never optional.

Start with one. Add the next when the work asks for it.

Beginning with a single service is a supported way to use Proxy rather than a trial of it. Nothing about the first service changes when a second arrives.

A service works on its own
Storage is useful with nothing else enabled. So is Processor, and so is Sign. None of them requires a second service to be switched on first.
A service is added, not migrated to
Enabling a second service adds a scope to your integration. The first service keeps its keys, its calls and its usage history unchanged.
Services meet on your records, not in a hidden pipeline
Processor takes a stored object you name. Sign puts a document you name in an envelope. There is no orchestration layer you have to model your work inside.

What "prove" resolves to.

Prove is not a service you buy. It is four artefacts the other services produce while they run, and you can read all four without enabling anything extra.

Audit trail

The event, the resource, the named actor and the time it was recorded.

On every mutation, by every service.

Usage ledger

The operation key, the quantity, the billing unit, the cost and the status.

On every metered operation, charged or free.

Delivery record

The outcome, the attempt history, and whether a retry has been made.

On every message sent and every webhook attempted.

Signature validation

The server-side verdict, kept with the signature it belongs to.

On every signature submitted for capture.

GET /api/v1/audit?resource=01k5m7z4…

{
  "data": [
    {
      "event": "storage.object.created",
      "resource": "01k5m7z4h9c1e8ptw2yb3rkq5d",
      "actor": { "type": "integration", "name": "Claims portal" },
      "recorded_at": "2026-08-14T09:40:58+00:00"
    },
    {
      "event": "processor.job.completed",
      "resource": "01k5m8f2r7q0x3v9tzcd4npb6h",
      "usage": { "operation": "ocr.document", "quantity": 1, "status": "charged" },
      "recorded_at": "2026-08-14T09:41:07+00:00"
    }
  ]
}

The two calls from the integration example, seen from the evidence side. The actor, the operation and the charge status are all on the record, so a question asked six months later does not depend on log retention.

Five shapes of work, from one catalogue.

Each of these composes services that were enabled separately. None of them needed a workflow engine to be modelled first.

Claims handling

Turn a folder of photographs into a decision

A customer uploads what they have from a phone. Proxy reads it, works out what each file is, and keeps the originals with the extraction beside them.

Services used, in order: Storage then Processor then Storage

Evidence
Original file, extraction job, and the actor on both.

Legal operations

Generate the document, then get it signed

Fields already held on the matter populate your template. The document is stored, sent as an envelope, signed in the browser and returned to both sides.

Services used, in order: Documents then Sign then Communications

Evidence
Envelope status history, signature verdict, delivery record.

Field services

Book the visit inside your own product

Availability comes from the constraints you publish. The customer picks a slot in your page, and the appointment attaches to the job rather than to a calendar nobody else can see.

Services used, in order: Calendar then Communications

Evidence
Booking event with who, when and against what.

Regulated servicing

Keep every message with the case

Outbound email and SMS are sent on the organisation's behalf and recorded against the record. Inbound replies land in the same place. SMS is metered by segment, so a long message is not under-counted.

Services used, in order: Communications then Storage

Evidence
A delivery record per message, in and out.

Customer onboarding

Verify the person and the paperwork together

An address is resolved before it is stored, the identity document is checked, and the outcome is recorded with the application rather than in an operator's inbox.

Services used, in order: Address Lookup then Identity then Storage

Evidence
Check outcome, recorded against the application.

See it against your own work.

Tell us the shape of the work and we will say which services cover it, which do not, and what the operations would be. Where something does not fit, we will say that too.

Request access Browse the services

Stages covered
Capture, Process, Store, Coordinate, Execute, Prove
Enabled how
One service at a time, by agreement
Reference
Full API documentation at platform.poweredbyproxy.co.uk