Trust center: every control, with its status and its evidence.

This page lets you check each control yourself. It lists every control with its real status, generated from the same register the engineering team maintains, and leaves the judgement to you.

  • 177 Implemented
  • 31 Enterprise implementation
  • 11 Planned
  • 53 Not in place
  • Implemented Built into the software, and covered by automated tests or a recorded rehearsal.
  • Enterprise implementation Provided by the environment the software is deployed into, as the deployment templates set it up.
  • Planned Written or designed, not yet in effect.
  • Not in place Does not exist today. No date is promised.

Every status on this page comes from the engineering register, with the file or test that shows it.

Where it stands

  • Release 2.28.0 runs on Kelynto's own Azure staging environment in Central US, deployed by GitHub Actions on every merge to main with health checks and automatic rollback, since 17 November 2026. No customer is hosted and no deployment has run in a customer's environment.
  • Kelynto holds no SOC 2 report, ISO 27001 certificate or penetration test report today; the controls below carry their real status, and the security review pack is available on request.

Architecture

  • Small, fixed set of components Implemented

    The product is a web container, an API container, a scheduler job and one PostgreSQL database. Nothing else stores customer data

  • Containers run without privileges Implemented

    The API and scheduler run as a non-root user with a read-only root filesystem and no-new-privileges in the supplied compose file; the web container is unprivileged nginx. The container rehearsal checks each of these

  • Read-only root filesystem on Azure and AWS Not in place

    On Azure Container Apps and on AWS Fargate the supplied templates do not set a read-only root filesystem (the platforms do not offer the tmpfs mount the API needs in the same way). The containers still run as a non-root user

  • One entry point Implemented

    Only the web container is reachable from outside. The API, its metrics endpoint and the database are reachable only inside the deployment's network. The rehearsal checks that no other port is published and that /metrics is not served outside

  • Edge controls for the public routes Implemented

    The web container limits /public/v1 per client address and for all clients together, answers CORS for listed sites only, refuses writes from other origins, and can switch the public routes off without touching the product API. 35 checks run against a live nginx

  • Browser security headers Implemented

    Every page carries a Content-Security-Policy (default-src 'self', no framing, no plug-ins), HSTS, nosniff, a no-referrer policy and a permissions policy

  • Private networking Enterprise implementation

    The Azure kit can place the database, Key Vault and registry behind private endpoints and give the application no public address at all (internal ingress)

  • Web application firewall Enterprise implementation

    The Azure kit can put Azure Front Door with a managed rule set in front of the application, and the origin then refuses requests that did not come through it. The AWS module attaches an AWS WAF web ACL

  • Kelynto Managed (hosted service) Planned

    A multi-tenant service operated by Kelynto. Release 2.28.0 runs on Kelynto's Azure staging environment in Central US, deployed by GitHub Actions on every merge to main, since 22 November 2026; the environment has run the product since 10 October 2026. No service hosts customers

  • Multi-region or active-active operation Not in place

    One region per deployment. A second region is used only for geo-redundant database backups when that option is on

  • Cross-browser testing Not in place

    Tested in Chromium only. Firefox, Safari, Edge and mobile widths were not tested

  • Accessibility assessment Not in place

    No assessment against WCAG and no testing with assistive technology has been done

Data handling

  • Aggregates only Implemented

    The data contract asks for weekly aggregates by store and category. There is no field for shoppers, baskets, payments or employees

  • Uploads are parsed as data Implemented

    Uploaded files are size-limited, streamed to a temporary file, parsed as tabular data and never executed. A file with too many bad rows is rejected whole

  • Logs carry no business data Implemented

    Application logs are structured lines with a request id. Request bodies, sales figures, visitor messages and email addresses of leads are not logged. The web container's access log omits query strings and referrers, and the API's own access log is switched off

  • Complete list of outbound connections Implemented

    Every place the backend opens a network connection is listed with what is sent, the default and the setting that disables it. The list was made by reading the code, not by observing traffic

  • No call home Implemented

    The software contains no telemetry, licence check or update check addressed to Kelynto

  • Outbound lookups can be switched off and checked Implemented

    A tool in the API image shows, checks and switches off every outbound signal source and the external language model for a workspace, and writes the change to the audit log. Executed in the external database rehearsal

  • Deployment-wide switch that forbids outbound lookups Implemented

    KELYNTO_OUTBOUND_SIGNALS=false forbids every weather, alert, event and road-work lookup for every workspace, whatever its settings say: no adapter is built. A workspace admin cannot change it; the settings screen shows the sources as locked and kelynto onboard-check reports it. Executed in tests with spy adapters; not observed on a network

  • Forecasts and public feeds are kept as issued Implemented

    Every forecast, weather alert and road-work feed the deployment fetches from a public source is kept with its address, the time the source issued it, the time it was collected, its valid period, a SHA-256 and the raw payload. A later fetch adds and never replaces. The tables accept new rows only: the application's database role holds INSERT and SELECT on them and a trigger refuses UPDATE, DELETE and TRUNCATE. A workspace's archive is behind the same row-level security as its other data. Tested on PostgreSQL 16 with the two roles. No collection has run against a live source

  • Website visitor text is redacted Implemented

    Card-like numbers, credentials, email addresses and phone numbers are removed from assistant messages before they are stored or sent anywhere. The client address is kept only as a keyed hash that changes every day

  • No third-party trackers Implemented

    The web app and the public routes load no third-party script and set no analytics cookie. The Content-Security-Policy allows scripts from the application's own origin only

  • Data residency commitment Not in place

    The region is chosen at deployment. No contractual residency commitment exists for a hosted service, because none is running. In a Customer Environment the customer chooses the region. The product records a region per workspace and compares it with the deployment's declared region (next row); it does not place or move data by region

  • Data region recorded per workspace and checked against the deployment Implemented

    An admin or the operator records the region a workspace's data is to be kept in. It is shown under Admin, Security, sent as a response header with every answer for the workspace (exports included) and written into the audit export. The operator declares the deployment's region (KELYNTO_DEPLOYMENT_REGION); an admin cannot record another one, and kelynto region-check fails when a recorded region differs from it. Both are statements: Kelynto cannot see where its database, backups or replicas are

  • Written data classification and handling policy Not in place

    Not written yet. It is on the policy list

  • Every validation problem has a location Implemented

    Each problem of an uploaded file names its row, its column, the value found, the rule broken and a suggested fix, or says that it concerns a column or the whole file. The code has no way to record a problem without one. The complete list downloads as a file

  • One validation path for every way a file arrives Implemented

    A file uploaded in the browser, sent to the inbound API or fetched by a scheduled drop goes through the same size limits, validator, saved mapping, loader and audit event

  • Oversized files, decompression bombs and disguised files are refused Implemented

    A request body is cut off at the size limit while it arrives, whatever length it declares; a workbook's unpacked size and compression ratio are checked before it is unpacked; archives and files whose content is not what their name says are refused. Each is attempted in a test

  • File names are never used as paths Implemented

    No file is written to a path built from a name it arrived with, from a browser, an API caller or a remote listing. A name is reduced to its base name before it is stored or shown, and listing entries that point outside the configured folder are skipped

  • Exported CSV cells cannot run as formulas Implemented

    Every CSV file the application writes from stored text neutralises a cell that a spreadsheet would run as a formula, in the problem file and in the reporting export

  • What leaves follows the same rule as the screens Implemented

    The outbound API, webhook messages and the reporting export state an amount for a recorded cause only, list context without an amount, state the part not explained, and carry no score. Tests walk every key of every answer

  • Webhooks cannot reach inside the deployment Implemented

    A webhook address must be public https. The name is resolved once before each delivery, every address it resolves to must be public, the connection goes to that checked address, and redirects are not followed. Attempted in tests with private, loopback, link-local and rebinding addresses

  • Scheduled drops cannot reach inside the deployment Implemented

    An SFTP host, storage endpoint or container address must be public, by the same check, when it is saved and at every run. No setting or request produces a policy that allows an inside address

  • Webhook deliveries are signed Implemented

    Each delivery carries an HMAC-SHA256 signature over a timestamp and the body, made with a secret that is shown once. Failed deliveries are retried with a growing pause and every attempt is in a log the workspace's admin can read

  • Deployment-wide switches for webhooks and scheduled drops Implemented

    KELYNTO_WEBHOOKS=false and KELYNTO_SCHEDULED_DROPS=false remove each feature for every workspace: nothing can be added, queued, sent or fetched, whatever was configured before. A workspace admin cannot change them. Executed in tests

  • Store addresses are not sent anywhere unless the operator configures it Implemented

    Coordinates come from the stores file, a form or a places file the customer loads. The online geocoder does not exist until KELYNTO_GEOCODER_URL is set, and is refused when outbound lookups are forbidden and in sample workspaces. It has not been run against a live service

  • Scheduled drops and webhooks exercised against real services Not in place

    Both were built and tested against servers started inside the test suite on the same machine (an SSH server, an S3 stand-in, an Azure Blob stand-in, an https receiver). Neither has run against a cloud storage service, a customer's server or over the public internet

Authentication

  • No passwords stored Implemented

    Kelynto holds no password and no password hash. Sign-in is by a customer's identity provider or by an emailed single-use link or code

  • Tokens verified against the customer's own provider Implemented

    Signature, issuer, audience and expiry are checked against the keys of the provider registered for that tenant. Only asymmetric algorithms are accepted. A token from an unregistered issuer is refused

  • The tenant comes from the verified token only Implemented

    No request header or unsigned value selects a tenant. An issuer can be registered to one tenant only

  • Multi-factor authentication through the customer's provider Implemented

    With the customer's own identity provider, MFA and conditional access are enforced there and Kelynto accepts only that provider's tokens for the workspace

  • Entra ID app registration script Enterprise implementation

    A script creates the two Entra app registrations (API and single-page app), the app roles and the optional claims, and prints the values the deployment needs. Its commands are checked against the installed Azure CLI and its logic was rehearsed against a stand-in; it has not run against a real directory

  • Built-in sign-in by emailed link or code Implemented

    Single-use, ten-minute links (256-bit token, carried in the URL fragment, redeemed by POST) and six-digit codes bound to the browser that asked, with attempts counted atomically. Off by default

  • Server-side sessions that can be revoked Implemented

    Built-in sessions are rows in the database. Refresh tokens rotate on every use and reuse ends the session. Access tokens live ten minutes and are checked against the session on every request, so revoking takes effect on the next request. A person ends one or all of their own sessions; an admin ends one session, or every session of a member, for their workspace. Each is in the workspace's audit log

  • Rotating signing keys, encrypted at rest Implemented

    The built-in issuer signs with ES256 keys it creates, rotates every 30 days by default and stores encrypted with a key derived from a deployment secret. Production refuses to start without that secret

  • Session cookies are confined Implemented

    The refresh cookie is HttpOnly, SameSite=Strict, Secure on https and scoped to the sign-in routes. Routes that act on it accept only the application's own origin and JSON bodies

  • Second factor for built-in email sign-in Implemented

    An account can set up an authenticator app (time-based one-time codes, RFC 6238). From then on a session opens no workspace and reaches no account route until the current code, or a recovery code, has been entered. A workspace admin can require a second factor of everyone who signs in to the workspace by email; it takes effect on each member's next request. Optional per account until a workspace requires it

  • Attempts on the second factor are limited and locked Implemented

    Each try takes one of five attempts in one database statement before anything is compared, so parallel tries cannot exceed the number. After five wrong codes the factor is locked for 15 minutes; while locked a right code is refused too. A code is accepted once, and only for its own 30 seconds and the step either side

  • Recovery codes, shown once, stored hashed Implemented

    Ten single-use codes are shown when the authenticator is set up and never again; only salted scrypt hashes are kept. The authenticator secret is stored encrypted. Removing the factor or making new codes needs the current code. An operator can remove a lost factor with a stated reason, which ends the person's sessions and is audited

  • Phishing-resistant second factor Not in place

    The second factor is a time-based code. There are no passkeys and no hardware security keys, so a code given to a fake sign-in page in real time can be used by whoever runs it

  • Kelynto does not check the identity provider's second factor Not in place

    For people who sign in through a customer's identity provider, the second factor is that provider's. Kelynto holds none for them, says so on the Security screen, and does not read a claim that would show whether the provider asked for one

  • No sign-in code in a subject line Implemented

    The six-digit sign-in code is in the body of the message only; the subject is fixed, so the code does not show in a notification that prints subjects

  • Idle timeout and session lifetime per workspace Implemented

    A workspace admin sets an idle timeout (5 minutes at the least) and a longest session (1 hour at the least) for built-in sessions. A workspace can shorten the deployment's own limits and cannot lengthen them. Both are checked on every request and at renewal: a session past a limit is ended although its access token is still valid

  • Session limits for identity provider users Not in place

    Kelynto holds no session for people who sign in through a customer's identity provider: idle timeout and session lifetime are that provider's settings, and an issued token works until it expires

  • API keys for programs: scoped, expiring, stored hashed Implemented

    A workspace admin makes a key with a name, one or more of four scopes (read data, write data, read reviews, read audit) and an expiry of a year at most. The key is shown once; its SHA-256 and a prefix are kept. A key does only what its scopes name, in its own workspace: no editing, publishing, runs or administration. Revocation and expiry take effect on the next request; rotation gives a new key and the old one an overlap of 0 to 168 hours. Requests are rate limited per key

  • Address allow list per workspace Implemented

    A workspace admin saves CIDR ranges, IPv4 and IPv6. Every request for the workspace, a person's or an API key's, on every workspace route, is then served only from inside them. A list must contain the address it is saved from, and the operator can clear a list with a stated reason

  • The forwarded-for header is believed only from the deployment's own proxy Implemented

    The client address is the socket peer, or the entry our proxies appended to X-Forwarded-For when the peer is inside KELYNTO_TRUSTED_PROXIES. In a deployment that declares proxies, a request from any other peer, or with fewer header entries than there are proxies, is counted for rate limiting at its socket address and is unverified: no allow list can be saved from it and an existing one admits nobody. A wrong proxy setting therefore shows as "no list can be saved", not as a list that admits everyone. Saving a list from a private address needs the admin's explicit confirmation

  • Every kit names the API's own proxy Implemented

    Compose and the single VM name the private ranges (the API has no port on the host). The AWS module names the private subnets of the web containers, which are the only peers its security group admits. The Azure template names the Container Apps subnet and 100.100.0.0/16 as a parameter. Each is checked as text and against the address rule; the AWS module passes tofu validate

  • Address allow lists behind a real proxy Not in place

    No kit has run behind a real proxy. The ranges the Azure template names for the Container Apps ingress come from the platform's documentation and are not verified against an environment; if they are wrong, no list can be saved until the operator corrects them. A hop count that is too low behind a content delivery network cannot be detected by the application

  • Resistance of the six-digit code to sustained guessing Implemented

    After ten wrong codes for an address within seven days, messages to that address carry the link only (256-bit token), so no further code can be guessed. Wrong attempts against a request that could never succeed do not count, so the lock cannot be held by a third party. Found in review as B-4 and B-5, fixed and re-tested by execution on 3 October 2026

  • "Continue with Microsoft or Google" Planned

    Written and tested with locally signed tokens. Never verified against the real providers: no app registration exists

  • Automated user provisioning (SCIM) Implemented

    A SCIM 2.0 service per workspace (RFC 7643 and 7644: Users and Groups with create, read, replace, PATCH, delete, filter and paging). The identity provider authenticates with a provisioning token that opens the SCIM routes and nothing else; it is shown once, stored as a hash and revoked at once. Tested from the request shapes Microsoft Entra ID and Okta document

  • Deactivation through SCIM ends access at once Implemented

    A member deactivated or deleted by the identity provider is deactivated, their sessions to the workspace are closed and the API keys they made are revoked, in one transaction; while the workspace has an active provisioning token they are not reactivated from Kelynto (the provider restores them; 2.15.0). The owner, the break-glass admin and the last active admin are never deactivated or demoted this way

  • SCIM exercised with a real identity provider Not in place

    No real identity provider has been connected to the SCIM service. The first connection of each provider is checked with a test group

  • Customer self-service registration of an identity provider Implemented

    A workspace admin sets up single sign-on in Admin, Sign-in: Kelynto reads the provider's OpenID Connect discovery document, the settings stay a candidate until a test sign-in passes the same verification every request gets, and only tested settings can be switched on. An operator can still register a provider at the command line

  • An email domain is routed to a provider only after it is proven Implemented

    The admin publishes a DNS TXT record at _kelynto-challenge.<domain>. An unverified domain routes nobody, and a domain belongs to one workspace in the deployment

  • Required single sign-on keeps one way in Implemented

    Single sign-on cannot be required without naming one admin who keeps email sign-in. Every sign-in through that exception is written to the audit log in its own transaction

  • Self-service single sign-on exercised with a real identity provider Not in place

    Discovery, the test sign-in and domain verification were tested with stand-ins: locally signed tokens and a stubbed DNS answer. No real identity provider or DNS zone was used

  • Throttling of unauthenticated and failed requests Implemented

    Requests without credentials and refused credentials count against the caller's address. Sign-in mail is limited per address and per client and limited at the edge for all clients together. Every message the deployment sends (sign-in, the no-workspace notice, invitations, lead notifications) passes one gate that counts in the database and stops at a ceiling for 24 hours (KELYNTO_SIGNIN_MAIL_DAILY_CAP)

  • Operator reports need a verified email from a single-directory provider Implemented

    The operator reports in the web app are off unless addresses are listed. An operator is accepted only with a token of the shared provider whose email claim is verified by the token itself (email_verified, or xms_edov from one Entra directory). The check cannot be switched off, and the API refuses to start with operators named and a multi-directory Microsoft issuer

Authorisation

  • Role-based access inside a workspace Implemented

    Four roles with fixed permission sets. Every route that reads or changes workspace data declares the permission it requires

  • The roles screen shows what is enforced Implemented

    Admin, Roles is written from the permission table and the route rules the API enforces, and explains for one member each capability with yes or no and why. A test fails when the words and the enforcement differ

  • Custom roles Not in place

    There are four fixed roles. A workspace cannot define another

  • Access limited to some stores Implemented

    An admin can limit a member who is not an admin, an API key or a webhook to the stores of some regions, districts or stores, see the stores it covers before saving, and map provisioning and single sign-on groups to such limits. A limited caller reads those stores only and nothing of the company's totals: a restrictive row-level security policy on every table keyed by store narrows each of their transactions in PostgreSQL, the application narrows the same tables, and every route a limited caller can reach builds its answer for their stores, while every other route refuses them before it runs. A limited member reads, sends and shares their stores' review and changes nothing of the company's review; a limited planner or analyst records causes and actions about their own stores only (2.14.0). A review a colleague sends them is built for their stores alone, with its own file and link, while the others on the message get the review as sent; a member none of whose stores it is about is named and nothing is sent (2.15.0); what a sender learns of other members through the send is names and roles, with a member's address and stores given to admins only (2.16.0). Going below release 2.13 is refused while any limit exists (2.14.0). Every change of a limit is audited. Tested on every surface, on SQLite and on PostgreSQL as the runtime role, with two members of one workspace limited to different regions. In release 2.13.0; on Kelynto's Azure staging environment since 19 October 2026

  • Roles from provisioned groups are mapped by an admin Implemented

    A pushed group gives a role only where a workspace admin mapped its name to one, and the screen shows which members would change role before the mapping is saved

  • Every route has a declared access rule, and a test asks each route whether it holds Implemented

    Every route of the API is listed with who may call it, the permission it needs and the API key scope that opens it, or the reason it needs no sign-in ([route-access.md](route-access.md), written from the list). A test walks the routes of the running application: a route without a rule fails, a route whose code asks for another permission fails, and every workspace route is asked without credentials, with an ended session, past the workspace's session limits, without the second factor, from outside the address allow list, with each key scope and as each role

  • An API key holds its scopes and nothing else Implemented

    A request made with a key is checked against the permissions the key's scopes stand for, not against a role. A request outside them is refused and the refusal is recorded. A key cannot make, list, rotate or revoke keys

  • Security policy is changed only through its own routes Implemented

    Session limits, the second-factor rule, the address allow list and the data region are changed by dedicated admin routes, each with its own checks and audit event. The general settings route refuses a change to them

  • Roles can be managed in the customer's identity provider Implemented

    With the customer's own provider, an app-roles claim is the source of the user's role, and removing the role there removes access on the next request

  • A workspace keeps an admin Implemented

    The last active admin cannot be demoted or deactivated, and the owner of a self-service workspace can be changed only by the owner

  • Invitations bind address and role Implemented

    An invitation is for one address and one role, works once, expires, and can be accepted only by a session that proved control of that address

  • Invitation mail cannot carry an inviter's text or be sent in bulk Implemented

    Fixed subject; the workspace's and the inviter's names appear once, framed as unverified, cleaned to plain characters and withheld when they hold an address or imitate Kelynto. Limits per inviter, per workspace and per recipient are counted in the database, invitations count against the deployment's daily mail ceiling, and under sign-up by approval a workspace invites only once approved

  • The allowed email domains are the owner's to change Implemented

    Only the workspace owner changes the list. It keeps the owner's and the acting admin's domains, the owner is never closed out by it, and a change that would close out current members names them and needs a confirmation. Changes and refused attempts are audited

  • Adding a member requires that person's consent Implemented

    In a workspace people sign in to by email, members join only by accepting an invitation: adding an address directly is refused. A membership a person did not create or accept is never opened for them automatically. An admin sees and can end only sessions that have that workspace open, and ending one bars it from that workspace without signing the person out elsewhere. Found in review as B-2, fixed and re-tested by execution on 3 October 2026

  • Sample workspace personas are confined to sample data Implemented

    A visitor of a sample workspace can look through every persona, including admin, and can change nothing under the administration and organisation routes: no users, settings, invitations or sessions. Found in review as B-1 and B-3, fixed and re-tested by execution on 3 October 2026

  • A share link opens one published review and nothing else Implemented

    A member with the sharing permission can make a link to one published version of a review. The token is 32 random bytes, stored only as a SHA-256 hash and shown once. A link expires (14 days by default, never more than 90), can be revoked, can carry a passphrase that locks after five wrong tries, counts its views, and stops opening when the workspace switches share links off. Share links are off for a new workspace until an admin switches them on, and a link opens only from inside the workspace's address allow list when it has one. Every other route answers 401 to the token. Making, opening and revoking a link are audited

  • A review is sent only to the allowed list Implemented

    A review leaves by email only to members of the workspace and to addresses at domains the workspace admin approved; a message with any other address is refused whole. Sending is limited per message and per person per hour and is audited. With no mail relay nothing is sent: the message is drafted for the member

  • An uploaded logo cannot carry script Implemented

    A logo must be recognised as a PNG or JPEG from its bytes; SVG and every other format are refused. The pixels are drawn into a new PNG encoded by Kelynto and the upload is discarded. The stored image reaches a browser only inside JSON, never from an address of its own

  • No cross-workspace user Implemented

    No application role can read more than one workspace. Operator reports on leads are a separate path that never binds a tenant and is off unless operator addresses are configured

  • Operator access to production is logged per person Not in place

    Command-line changes are audited under the container's service user, which shows that a change came from the command line, not which person made it. Who opened the shell is in the hosting platform's logs

  • Periodic access reviews Not in place

    No access review process exists. It is on the readiness list

  • No vendor access in a Customer Environment Implemented

    The software gives Kelynto no account, key or network path into a customer's deployment. Any access for support is something the customer grants in its own cloud

  • One authorisation check for data in and out, people and API keys alike Implemented

    Every route of the inbound API, the outbound API, the reporting export, webhooks and scheduled drops asks for a permission through the same check as the rest of the API. A signed-in caller holds the permissions of its role; an API key holds the permissions its scopes stand for: submitting a file needs Write data, data health, submission status and the reporting export need Read data, outbound reviews, findings and actions need Read reviews. Webhooks, scheduled drops, saved mappings and store coordinates take no key. A test asks every route with every scope

  • What is reached without a workspace session is stated and tested Implemented

    A share link is opened with no sign-in, and webhook deliveries and scheduled drops are requests the application sends. For each, the page of route rules states which controls apply (the share-link switch, expiry, revocation, passphrase, the workspace's address allow list, request limits, the audit log; the deployment's switches, admin-only configuration, public addresses only, signing, sealed secrets) and which cannot (session limits, the second factor, key scopes), and a test asks each statement through the routes an admin uses

Tenant isolation

  • Tenant filter in the application Implemented

    Every ORM query from a tenant-bound session is filtered by tenant; a write for another tenant raises an error

  • Forced row-level security on every tenant table Implemented

    Each tenant-owned table has FORCE ROW LEVEL SECURITY with a policy for reads and writes. A test fails when a tenant-owned table is added without one

  • Fails closed Implemented

    A database transaction bound to no tenant sees zero tenant-owned rows and can insert, change or delete none

  • The application is not a database superuser Implemented

    The database bootstrap creates the two roles without superuser, BYPASSRLS, CREATEROLE, CREATEDB or REPLICATION, logs in as each and refuses to finish otherwise. Executed on 6 October 2026 against a local PostgreSQL 16, with a superuser administrator and with one that is not

  • Isolation is checked on the running deployment Implemented

    db_check.py reports whether the role can bypass row-level security, lists tenant tables without a forced policy and counts the rows visible without a tenant (must be zero). Post-deployment validation fails otherwise

  • Synthetic tenant check Implemented

    Validation creates a synthetic tenant, loads invented data, produces a review, checks that another tenant binding cannot see it, deletes it and proves nothing is left

  • Account tables have their own policy Implemented

    Accounts, sessions, sign-in requests and signing keys are visible only to statements that explicitly enter the accounts scope

  • The public site cannot reach tenant data Implemented

    The public routes open only sessions that are never bound to a tenant, and the database refuses the public tables to a tenant-bound session. The public write path can never read a lead back

  • Separate owner and runtime database roles Implemented

    The application connects as a runtime role that owns nothing and is not a member of the owner role. Sent as that role over a plain connection to PostgreSQL 16, each of these is refused: ALTER TABLE ... NO FORCE or DISABLE ROW LEVEL SECURITY, DROP or ALTER POLICY, DROP TABLE, CREATE TABLE, altering or dropping a function or trigger, SET ROLE to the owner. Migrations run as the owner role through kelynto migrate, which grants the runtime role exactly its privileges and verifies them

  • The API refuses an unsafe database role Implemented

    The API and the scheduler do not start as a role that owns application objects, is a superuser, has BYPASSRLS, can create objects or can rewrite the audit log, nor when the database cannot be reached for the check. The one override is a development setting that production refuses

  • Upgrade of a database made with one role Implemented

    One script transfers ownership to the owner role, points the lookup policies at it, grants the runtime role and verifies the result. It is safe to repeat. Executed against PostgreSQL 16 on test databases with two tenants, not on a real deployment

  • The deployment kits create the two roles Enterprise implementation

    Docker Compose, the Azure template and the AWS module give the owner role's credential to the bootstrap, migration and owner-maintenance jobs only. Validated on 6 October 2026 as far as this: the Azure template compiles and its scripts pass a rehearsal against a stand-in command line; the AWS module passes a schema check and a policy scan; the Compose files were read by a test and not started. None has been deployed

  • A partner request is bound to one client Implemented

    Every partner API request that acts for a client names it; the client is looked up among the partner's own clients (an active workspace carrying the partner's tag) and the request is bound to that one workspace before any of its rows is read. Another partner's client, or a client of no partner, answers 404 on every route. A partner key opens no workspace route and a workspace's key opens no partner route

  • Partner records are closed to workspace code Implemented

    The nine partner tables (the six of the partner API, the partner's identity provider, its defaults for new client workspaces and its weekly run summaries) have FORCE ROW LEVEL SECURITY and one policy, partner_scope: outside the partner scope a transaction, bound to a tenant or not, reads no partner row and writes none. Executed on 4 November 2026 against a local PostgreSQL 16 as the runtime role

  • A partner's sign-in opens the partner's clients only Implemented

    A token from a partner's own identity provider is verified as any provider's token is, then opens one workspace per request, chosen among the partner's own clients (its channel and its tag both name the partner, and the client has not switched the partner's sign-in off), for an address at the partner's own email domains, with a role from the partner's mapping that is never admin. A client's own member is never signed in by a partner's token. Another workspace answers as one that does not exist. The partner's provider and the channel records are under the partner_scope policy. Executed on 4 November 2026 against a local PostgreSQL 16 as the runtime role

  • Leaving a partner ends the partner's access at once Implemented

    A workspace moves from a partner to Kelynto directly, or between partners, with the consent of one of the client's own admins and of the releasing side, or a Kelynto operator's override with a written reason. Nothing is copied. In the same transaction the partner's tag, client entry and summary lines go, the webhooks its key made are switched off, the workspace keys its people made are revoked, and its people are disabled or converted as the client chose. Every step is in the workspace's audit log and in both partners' logs

  • The tenant binding cannot be chosen by SQL Not in place

    The tenant a transaction is bound to is a session setting. SQL running as the runtime role could set it to each tenant in turn and read them all. A database role per tenant, or a signed value the database verifies, would close this; neither is built

  • The owner database role is constrained Not in place

    The owner role can alter tables and policies and rewrite any row. Nothing constrains it; its credential is given to the migration and maintenance jobs only, and who can read that secret is the hosting platform's access control

  • Dedicated single-tenant deployment Enterprise implementation

    A customer can have a deployment that serves only its tenant (KELYNTO_TENANCY_MODE=single), in its own cloud account

  • Separate encryption key per tenant Not in place

    All tenants of a multi-tenant deployment share the database's encryption at rest. There is no per-tenant key

  • Independent test of tenant isolation Not in place

    No third-party penetration test has been performed

Encryption

  • TLS for every browser connection Implemented

    The application is served over https only; HSTS is sent; plain HTTP is redirected. The single-VM rehearsal checks the redirect and the certificate path locally

  • TLS 1.2 or newer at the edge Enterprise implementation

    The AWS load balancer uses a TLS 1.2 and 1.3 policy; Azure ingress and Front Door are set to a minimum of TLS 1.2. Post-deployment validation checks that TLS below 1.2 is refused

  • Encrypted database connections Implemented

    The templates make the database server refuse unencrypted connections. The external-database rehearsal ran the application over TLS 1.3 against a server that accepts TLS only

  • Encryption at rest by the cloud service Enterprise implementation

    Database storage, backups, secrets and logs are encrypted at rest by the managed services the templates create (Azure Database for PostgreSQL, Key Vault, Log Analytics; RDS with storage_encrypted, Secrets Manager, CloudWatch Logs)

  • Customer-managed keys Enterprise implementation

    The Azure kit can encrypt the database with a key in the customer's Key Vault (postgresCmkKeyUri); the AWS module uses the customer's KMS key for the database, secrets, logs and registry when kms_key_arn is given. Neither has been deployed

  • Secrets live in the platform's secret store Enterprise implementation

    Passwords and keys are generated by the deploy scripts, stored in Key Vault or Secrets Manager and injected as references. Terraform state holds no secret value: the scripts put the values, the module creates only the containers for them

  • No secret in the repository or images Implemented

    Parameter files hold identifiers only; the images contain no credential. The Azure preflight reports parameter files that still hold placeholder values

  • Signing keys encrypted in the database Implemented

    Private signing keys are stored encrypted with a key derived from a deployment secret; production refuses to start without one of at least 32 characters

  • Application keys held in a key management service Not in place

    The key that protects the signing keys is derived from a setting. It is not held in a key management service or a hardware module, and the application has no code to use one

  • One interface for the keys of stored secrets Implemented

    Signing keys and authenticator secrets are encrypted, and code and address hashes keyed, with a key per purpose that comes from a key provider. The provider every deployment uses derives each key from KELYNTO_ACCOUNTS_KEY_SECRET, exactly as before the interface existed

  • Application keys from a customer's key service Not in place

    KELYNTO_KEY_PROVIDER=cloud-kms names an interface stub. No client for any key service is built in and none has been called. With it selected the API refuses to start and every request for a key fails; it never runs on the environment secret instead. Customer-managed keys for the application's own stored secrets do not exist

  • Authenticator secrets encrypted, recovery codes hashed Implemented

    The shared secret of a second factor is stored encrypted under a key of its own; recovery codes are stored as salted scrypt hashes; API keys as SHA-256 of 256 random bits

  • The owner database credential is kept from the application Enterprise implementation

    In the Azure template only the bootstrap identity has a role assignment that reaches the owner role's secrets; in the AWS module only the bootstrap execution role's policy names them; in Docker Compose only the dbinit, migrate and owner-maintenance services are given the value. Read by a test from the files; the Azure template is the one that stands up Kelynto's Azure staging environment, and the AWS module has not been deployed

  • One-time secrets stored as hashes Implemented

    Sign-in links, codes, refresh tokens and invitation tokens are stored only as hashes; the six-digit code's hash is keyed and bound to its request

  • Encrypted backups on the single VM Implemented

    Database dumps are encrypted with age before upload. The backup and restore drill ran locally with a directory in place of Blob Storage

  • Key Vault hardening Enterprise implementation

    Role-based access, soft delete for 90 days, optional purge protection and optional private endpoint only

  • Rotation procedures Enterprise implementation

    Step-by-step rotation for every secret is in the runbook. No rotation has been performed on a live deployment

  • Rotating the accounts key secret without signing everyone out Implemented

    A previous secret is accepted for decrypting stored signing keys only, and a command re-encrypts them under the current secret. Covered by a test; never performed on a live deployment

  • Field-level encryption of business data Not in place

    Sales, plan and in-stock figures are not encrypted column by column; they rely on the database's encryption at rest and on access control

  • TLS between nginx and the API inside one host Not in place

    In the compose and VM layouts nginx reaches the API over plain HTTP on the private container network of one machine

  • Customer-entered credentials are sealed and never shown again Implemented

    Webhook signing secrets and the credentials of scheduled drops are encrypted on arrival with an authenticated cipher keyed from the deployment secret and separated by purpose. No endpoint returns them, logs and audit events never hold them, and after the deployment secret changes kelynto accounts rewrap-keys seals them again. The key is derived from a setting, as stated under enc-keys-in-kms

  • SFTP servers are identified by a pinned host key Implemented

    Nothing is sent to an SFTP server until its host key matches the SHA-256 fingerprint an admin accepted; a changed key stops the run. Changing where a connection points requires its credentials to be entered again

Audit logs

  • Audit event for every state change Implemented

    Uploads, runs, commentary, publishing, labels, settings, user and role changes, and identity provider changes are recorded with actor, action, entity, request id and time

  • Where a request came from Implemented

    An event caused by a request carries the client address (by the deployment's rule for trusted proxies, marked when it came from a header no trusted proxy vouched for) and the user agent, inside the event's details, so the hash chain covers them. Shown on the audit screen and in both exports. Events of the command line and the scheduler carry none

  • Security changes and refusals are audited Implemented

    Changes to session limits, the second-factor rule, the address allow list and the data region; API keys made, rotated and revoked; every request served with an API key; requests refused by a key's scopes, by expiry or revocation, or by the allow list (at most once an hour per caller and reason); sessions ended by policy, by an admin or by the person; a second factor set up, removed, locked, reset by the operator, and a recovery code used

  • Settings changes keep before and after Implemented

    A settings change records the previous and the new value of each changed field

  • Command-line changes are audited Implemented

    Operator commands write audit events with the actor cli:<operating-system user>. This shows the change came from the command line; it does not identify a person

  • Licence actions are audited Implemented

    Every action Kelynto takes on a workspace's licence (issued, extended, plan or limit changed, suspended, reinstated, revoked) is written to that workspace's audit log with before and after, and to a licence log that the application's database role can only add to

  • Admins can read the audit log Implemented

    Workspace admins read their audit log in the app and at GET /api/v1/admin/audit: each event in words, filtered by what happened, who, kind of item and period

  • Admins can check the chain and download a period Implemented

    An admin verifies the hash chain of the workspace's log from the screen and downloads the events of a period as CSV or JSON Lines. The check and each download are themselves recorded

  • Audit retention Implemented

    Audit events are kept for audit_retention_days (default 2555, minimum 365) and never less than the data retention. They are removed only by the owner-side maintenance command, oldest first, so what remains is still one verifiable chain

  • Sign-in and session trail Implemented

    The built-in sign-in records requests, failures, lockouts, sessions and workspace creation in an account trail kept 730 days

  • Platform diagnostics to the customer's log workspace Enterprise implementation

    The Azure kit sends container and database diagnostics to a Log Analytics workspace, which can be one the customer already has. The AWS module writes to CloudWatch log groups with a retention the customer sets

  • The application cannot change or remove audit events Implemented

    The database role the application connects as holds INSERT and SELECT only on the audit table, and a trigger owned by the owner role rejects UPDATE, DELETE and TRUNCATE whatever the grants say. Executed against PostgreSQL 16, including with the grants given back by mistake. PostgreSQL only: there is no such rule on the SQLite used in development

  • Tamper-evident audit log Implemented

    Each event carries its position in the workspace's chain, the hash of the event before it and its own SHA-256 hash, given by the database when the event's transaction commits. Positions are taken under a lock, so concurrent writers cannot fork the chain. A command walks the chain and names the first break; a test tampers as the owner role in six ways and each is found. Events from before the chain existed are covered only from the migration onward

  • Removal of audit events is owner-side and recorded Implemented

    Audit events leave only through retention and the deletion of a workspace, on a connection of the owner database role that names its reason. The database writes each removal (who, why, how many, the hash of the last event) to a table that itself rejects changes. A sample workspace registered as such when it is created is the one exception, and its removal is recorded the same way

  • Write-once or externally anchored audit store Not in place

    The owner database role can disable the trigger and rewrite events with their hashes and the chain head. That is detectable only by comparing with hashes exported earlier and held elsewhere. There is no write-once store and no anchoring of hashes outside the database by the product

  • Export of audit events with their hashes Implemented

    Admins export their workspace's audit events as JSON Lines, oldest first, in pages with a resume cursor, each line carrying its chain hashes (GET /api/v1/admin/audit/export). An operator command does the same to a file and continues where it stopped. A copy can be verified without the database

  • Push of audit events to a SIEM Not in place

    The export is pulled by the receiving system or scheduled by the operator. There is no push to a log system and no connector for a named product

  • Record of sensitive reads Implemented

    Recorded every time: the two CSV exports, a review download, an audit export. Recorded once per person in 15 minutes: viewing the audit log, the settings, the member list, the invitations and other people's sign-in sessions. Recorded as a sign-in: a person's first request after 8 hours, and a verified identity that is refused for a workspace

  • Record of every record viewed Not in place

    Ordinary page views (which review, finding or store a person looked at) are not recorded. The operator pages of the public site are outside the workspace audit log

  • Changes to data connections are audited Implemented

    Creating, changing and removing a webhook or a scheduled drop, rotating a webhook secret, accepting an SFTP host key, saving or forgetting a column mapping, reading a stored file again, every change of a store's coordinates and every download of the reporting export write an audit event. None holds a credential, and a webhook address is recorded by host only

Backups

  • Automatic backups with point-in-time restore on Azure Enterprise implementation

    The Azure kit sets backup retention (parameter, default in the production file) and optional geo-redundant backup on the PostgreSQL server

  • Automatic backups on AWS Enterprise implementation

    The AWS module sets backup_retention_period, deletion protection and a final snapshot on the RDS instance. Statically checked only

  • Encrypted off-machine backups on the single VM Implemented

    backup.sh dumps, encrypts and uploads; restore.sh restores into a fresh database owned by the owner database role, runs the bootstrap and the migration and verifies the audit chain. The two scripts ran in a local container rehearsal on 3 October 2026, before the two database roles; restore.sh has changed since and that rehearsal was not repeated. Its dump, restore, bootstrap and migrate sequence was executed without containers against PostgreSQL 16 on 6 October 2026, for a current backup and for one from a single-role database

  • Restore procedure Enterprise implementation

    Step-by-step restore for point-in-time, lost region and the VM, and a restore drill that does not touch production

  • Restore tested on a real managed database Not in place

    No restore of a managed database has been run, on Kelynto's Azure staging environment or on AWS. The VM restore ran locally

  • Backup point before an upgrade Enterprise implementation

    The upgrade scripts record the time before migrations run, so a point-in-time restore target is known, and refuse to roll the application back across a migration that is not backward compatible without an explicit downgrade

  • Committed recovery time and recovery point Not in place

    Design targets exist; none is committed in a contract and none has been measured on a cloud deployment

  • Customer can export its data Implemented

    A workspace admin makes a full export: one archive with every table of the workspace as JSON Lines, stores and weekly figures also as CSV, the audit log with its chain hashes, kept files, and a manifest with the SHA-256 of every file. Secrets are left out and the manifest says so. Proven on PostgreSQL with the two database roles

Monitoring

  • Health and readiness endpoints Implemented

    /healthz reports the version; /readyz checks the database. Container probes and the availability test use them

  • Usage report per workspace Implemented

    A workspace admin sees by week the members active, sign-ins, reviews published, files, API requests and webhook deliveries, counted from the audit log and the tables, with a definition of each figure, and downloads it as CSV

  • Application metrics Implemented

    Request, error, latency, rate-limit and background-run metrics by route template, plus counters for assistant outcomes, leads, notifications, sign-in requests and verifications, sign-ups, sample workspaces and mail. Not reachable from outside

  • Alert rules for a Prometheus scraper Enterprise implementation

    34 recording and alerting rules: error budget burn, latency, unhandled exceptions, stuck runs, and the public surface (sign-in outcomes, mail, sign-up, sample workspaces, the assistant, the daily ceilings). Checked with promtool; never loaded into a running Prometheus

  • Azure Monitor alerts Enterprise implementation

    Availability test, 5xx, restarts, database CPU, storage and liveness, scheduler failures and silence, error logs, and eleven log alerts for the public surface. Compiled and linted; the log queries have not run against a workspace

  • CloudWatch alarms Enterprise implementation

    Load balancer 5xx, unhealthy targets, database CPU, storage and connections, scheduler failures. Statically checked only

  • Daily ceilings on the public surface, with an alert metric Implemented

    New conversations, visitor messages, leads, browser events and model calls each have a ceiling per UTC day for the whole deployment, counted in the database. A refusal is counted in kelynto_public_daily_cap_total{kind} and logged; the alert rules of the three kits watch it, and an operator command shows the day's counts

  • Validation after every deployment and upgrade Implemented

    One script checks health, version, schema at head, the fail-closed isolation probe, sign-in discovery, the public surface's state, headers and transport, and runs a synthetic tenant that cleans up after itself. Executed locally against the compose stack with an external database (33 checks)

  • Counters for sign-in outcomes Implemented

    The built-in sign-in counts requests, verifications, sign-ups, sample workspace visits and mail by outcome, with closed label sets and no address in any label. On Azure, where nothing scrapes the counters, the alerts read log events and the web container's access log instead

  • Alert for a missed feed collection Not in place

    The daily collection of forecasts and public feeds logs each run and each failure, and kelynto feeds status shows the last collection per source. No alert rule fires when a day is missed

  • On-call rotation Not in place

    No rotation exists. Alerts go to one mailbox

  • Public status page Implemented

    A Cloudflare Worker at https://status.kelynto.com checks the web app, /healthz and /readyz of Kelynto's Azure staging deployment every 5 minutes from outside, keeps a rolling 90-day history, shows current state and 90-day uptime per component, the AI writer's check after each deployment (reported by the pipeline with its GitHub OIDC token) and an incident list kept through an authenticated admin endpoint, serves the same as JSON, and posts to a webhook after two failed checks in a row and on recovery when a webhook is set. Live since 2 November 2026; its uptime history starts that day. It watches staging, not a customer's service

  • Intrusion detection and security event monitoring Not in place

    No dedicated intrusion detection. The web application firewall option and platform logs are what exists

Incident response

  • Written incident procedure Implemented

    Severity levels, first actions, containment steps for suspected exposure of data, and a communication template

  • Containment switches Implemented

    A tenant can be deactivated, an identity provider disabled, a person's sessions ended, signing keys rotated and the public surface closed at the edge, each with one command or one setting

  • Requests can be traced Implemented

    Every response carries a request id that appears in the log line and on audit events written by that request

  • Rollback of a bad release Enterprise implementation

    Scripts roll the application back to the previous revision and refuse to cross a migration that is not backward compatible unless told to downgrade. Their logic was rehearsed against stand-ins for the cloud command lines, not against a cloud

  • Contractual breach notification Planned

    No customer contract or data processing agreement exists yet, so no notification period is committed

  • Incident exercise Not in place

    The procedure has not been rehearsed

  • Round-the-clock response Not in place

    One person, business hours, best effort

  • Vulnerability disclosure channel Planned

    A security.txt that names security@kelynto.com as the contact is in the site build of 3 October 2026 and is published when that build is uploaded. The policy text is written and is not on the site yet. The mailbox has to be created before the build is published

Subprocessors

  • No subprocessor in a Customer Environment Enterprise implementation

    The software runs in the customer's account and Kelynto holds none of the customer's data

  • Every outside service is listed Implemented

    Each service the software can contact, what it receives and how it is switched off is listed, from a reading of every network call in the code

  • Optional outside services are off by default Implemented

    The event source, road-work feeds, external language model, mail and the website assistant are off until configured. Weather lookups are the exception: on by default

  • Subprocessor register for the hosted service Planned

    A register exists as a working document with the companies a hosted service would use. No company is engaged, no data processing terms are signed

  • Notice of subprocessor changes Not in place

    No notice process and no subscription list exist

AI and LLM data flow

  • No model is called by default Implemented

    The commentary uses the template writer and the assistant is off unless a deployment and, for commentary, the workspace admin switch a provider on

  • The commentary model sees aggregated facts only Implemented

    The provider receives the week's facts document and nothing else

  • Model drafts are checked against the facts Implemented

    A draft with a figure or claim that is not in the facts is discarded and the template text is used

  • The website assistant cannot reach customer data Implemented

    It answers from the knowledge base only and its routes cannot open a tenant session

  • In `llm` mode a model only chooses approved entries Implemented

    The model replies with the ids of at most two of the entries retrieved for the question, and the visitor is shown the approved text of those entries, word for word. A reply that is anything but ids that were provided is discarded and the retrieval's own choice is shown. No wording written by a model is shown, stored or returned. Tests send hostile replies and a sweep of negations and contradictions

  • Every approved entry is held to a claims guard and a support check Implemented

    The tests run both checks over every entry of the knowledge base: a certification, compliance, SLA, customer, integration or price claim, a number, a status label or an availability claim must be backed by the entry's own sentences, and a link must be one the deployment configured. Lexical: they compare words, not meaning

  • The assistant's model mode is optional and off by default Implemented

    KELYNTO_ASSISTANT_MODE is unset (off) in every deployment file; llm has to be asked for, needs a provider key and cannot be combined with KELYNTO_EXTERNAL_LLM=false. Tested with a fake provider only

  • What became of each model choice is recorded and counted Implemented

    The outcome (passed, blocked, provider error) is stored with the message, with the reason and never the reply, and counted in kelynto_assistant_guard_total{outcome}

  • Visitor text is redacted before any model call Implemented

    Card-like numbers, credentials, email addresses and phone numbers are removed first; the visitor's text is wrapped as data with a per-request marker

  • Ceiling on model calls Implemented

    A daily ceiling for the whole deployment, counted in the database so that every API replica shares one number and a restart does not reset it. After it the assistant answers from approved text

  • The in-app assistant answers by fixed rules Implemented

    Unless the deployment allows the language-model mode and a workspace admin switches it on, no model is involved in an answer and nothing leaves the deployment

  • Every figure of an in-app answer is on a record it cites Implemented

    A checker runs on every answer in both modes; an answer with an amount, percentage, count or date that is not on a cited record, an amount or a cause for a record on file, or a statement of how sure it is, is replaced and logged. A test opens every source of every answer of the question set through the screen's own route and compares the figures

  • In the guided demo's model mode a model only picks one approved fact or tour Implemented

    Asked only when the fixed rules found no answer, the model is offered a short list of approved facts and tours by id and replies with one id or none. Anything else is ignored. The visitor is shown the fact's approved text or the tour's own lines, never the model's words, and every line passes the last claim check

  • One rule on every surface that can involve a model Implemented

    The website assistant, the guided demo and the in-app assistant read a model's reply with the same code, as a choice among what was offered and as nothing else. One test holds the three to one list of hostile replies: whatever the model replies, a person reads exactly what they read with the mode off

  • A daily cost cap on model calls, with an alert Implemented

    Model calls and model tokens for the website assistant and the guided demo are counted in the database against two daily ceilings for the whole deployment; past them no model is called and visitors get approved text. An alert rule tells the founder when a ceiling is reached. Tested with a provider that reports what it was paid and a clock the test holds, and the alert rule with the Prometheus rule tester

  • In the language-model mode a model only chooses a kind of question Implemented

    For a question the rules did not recognise it receives the question and the page name and may name one of the fixed kinds of question with its arguments. A choice outside the fixed set, the prompt in the output, or any provider failure gives the answer the rules give. Every sentence shown is put together from the records by the product in both modes; nothing a model writes is shown. Tested with a fake provider only, including hostile replies and a sweep of negations and contradictions

  • Text a customer typed into a record is never an instruction Implemented

    A store name, an action title or a planner's note that reads as an instruction is quoted or pointed to as data in both modes, and no record is sent to a model in either

  • Daily ceilings per workspace for the in-app assistant Implemented

    Questions and model calls are counted per workspace and UTC day in the database, so every API replica shares the numbers. After the ceiling for model calls, answers come from the records alone

  • Inference inside the customer's cloud Enterprise implementation

    With Azure OpenAI as the provider, the deployment can be pointed at the customer's own Azure OpenAI resource. Not exercised against a real resource

  • No training on customer data Implemented

    No code path sends customer data anywhere for training, and Kelynto holds no customer data

  • Reviewed data processing terms with model providers Not in place

    No provider processes customer data; Kelynto's own Anthropic key on its Azure staging environment serves the AI writer for the synthetic sample. No provider's data processing terms have been reviewed or signed

  • Sample workspace visitors cannot switch a model on Implemented

    Settings of a sample workspace, including the external writer and the outbound signal sources, cannot be changed by its visitors. Found in review as B-3, fixed and re-tested by execution on 3 October 2026

  • A visitor's sample workspace never reaches a model or an outside signal source Implemented

    Whatever the settings of a sample workspace say, the writer returns the template writer and the signal refresh asks no source: the check is in the writer and in the adapters, before any provider or adapter is built. Two operator-side exceptions, both under the sample allowance and only with KELYNTO_DEMO_LLM=true: the weekly sample template's review week is written by the deployment's model when the operator builds it, and visitors' copies carry that review without a provider call; and a showcase workspace an operator makes for a signed-in account may use the deployment's model

  • Deployment-level switch that forbids language models Implemented

    KELYNTO_EXTERNAL_LLM=false makes every commentary use the template writer and stops every model call for every workspace, whatever its settings say and whether or not a provider key is present. The settings screen shows the writer as locked. The website assistant cannot run in llm mode with it

Retention and deletion

  • Automatic purge by retention period Implemented

    The scheduler deletes each workspace's data older than its retention once a day and writes an audit event with the counts. Audit events past their own retention are removed by a separate command that runs as the owner database role

  • Audit retention runs on a schedule Enterprise implementation

    The Azure kit and the AWS module define a daily job for the owner-side maintenance; the single-VM kit installs a cron entry at first boot. The Azure job exists on Kelynto's Azure staging environment (kelynto-staging-owner-maint); no run of it on a customer's deployment is recorded. The AWS job and the VM cron entry are compiled and checked, not deployed. With Docker Compose elsewhere the operator adds the schedule

  • Retention per kind of data, with a preview Implemented

    Weekly figures, weekly reviews, outside signals, loaded file records and the audit log each have their own length. Before a change is saved the admin sees what it would remove, a change that removes data is confirmed twice, and the purge is held for 24 hours after a length is shortened

  • A workspace can delete itself, with a certificate Implemented

    An admin schedules the deletion by typing the workspace's name; every other admin is told by email, every member sees it on every page, and any admin can cancel during the grace period. The runtime database role only closes the workspace. The owner role removes it in one transaction, checks that no row is left, and writes a certificate that states what was deleted, when, by which role, the last hash of the audit chain and what remains in backups. The certificate cannot be changed or removed by the application

  • Deletion attested by a third party Not in place

    The certificate is Kelynto's own record of the deletion. Nobody outside the deployment attests it

  • Verified deletion of a workspace Implemented

    One script deletes a tenant and every row it owns in one transaction, verifies that nothing is left and rolls back if something is. It needs the owner database role, and is refused with the application's own role. Executed in the onboarding rehearsal against PostgreSQL 16

  • Retention of website visitor data Implemented

    Conversations, events and leads are purged after their periods; one person's lead and conversation can be removed on request

  • Housekeeping of sign-in data Implemented

    Expired sign-in requests, ended sessions, old account events, retired keys, abandoned empty workspaces and expired sample workspaces are removed by the scheduler pass

  • Retention of the feed archive Not in place

    Archived forecasts and feeds have no retention period of their own: they are kept until the workspace is deleted, and leave with it. Nothing removes them by age, and the application's database role cannot remove them

  • Uninstall removes the deployment Enterprise implementation

    Scripts remove a Customer Environment deployment, list what will be deleted first and require the name to be typed. Rehearsed against stand-ins for the cloud command lines

  • Deleted data leaves backups Not in place

    Backups cannot be edited. Deleted data remains in them until the backup retention (7 to 35 days) has passed

  • Self-service deletion of a built-in account Not in place

    A person can end sessions; there is no screen to delete the account itself. An operator can disable it

  • Export and deletion in every licence state Implemented

    A workspace admin can make and download the full export (one archive with every table the workspace holds, a manifest with a checksum for each file and the state of the licence), set what is kept and for how long, and the workspace's owner can ask for the workspace to be deleted and receive its certificate, whatever the state of the licence: trial, active, in grace, expired, suspended or revoked. A licence state makes a workspace read-only at most; it never deletes, hides or alters data. There is one export and one deletion in the product; the deletion takes effect after the days the screen states, and the rows are removed by the owner-side maintenance run

  • Written retention policy and data processing agreement Planned

    The defaults above are implemented; the policy document and the agreement that commits to them are not written

  • Loaded files are kept for a bounded time and amount Implemented

    A loaded file is kept compressed for 90 days by default, at most 2,000 MB per workspace with the oldest let go first, so that it can be read again after a mapping changes. The scheduler lets expired files go; the keeping can be switched off. They leave with their upload and with their workspace

  • Webhook delivery logs and drop histories are bounded Implemented

    Webhook deliveries are purged after 30 days by default; each scheduled drop keeps its last 200 runs. Both leave with their workspace

Customer-hosted deployment

  • Azure deployment kit Enterprise implementation

    Parameterised templates for subscription, resource group, region, an existing virtual network, private endpoints for PostgreSQL, Key Vault and the registry, private or public ingress, WAF, customer-managed key, managed identity, diagnostics, backups and probes. Compiled, linted and rehearsed against a stand-in; the standard shape stands up Kelynto's Azure staging environment, which runs release 2.28.0; the private shape has not been deployed

  • Preflight checks Enterprise implementation

    A script checks tools, sign-in, permissions, resource providers, quotas, name availability, the parameter file and the network before anything is created

  • Post-deployment validation Implemented

    The same validation script runs on every platform: health, version, migrations at head, the fail-closed isolation probe, sign-in discovery and a synthetic tenant that cleans up. Executed locally

  • Upgrades with a migration policy Enterprise implementation

    Migrations follow an expand and contract policy recorded in a registry; the upgrade scripts refuse an upgrade or rollback that would cross a migration that is not backward compatible without the documented steps

  • No long-lived cloud credentials Enterprise implementation

    On Azure the containers read secrets and pull images with a managed identity; on AWS with task roles. No access key is stored

  • Runs without a connection to Kelynto Implemented

    The deployment needs no licence server, no update channel and no Kelynto account. Images are built from the repository in the customer's own registry

  • Licence checked without a network Enterprise implementation

    A deployment that is licensed by file verifies a signed licence file (Ed25519) against public keys built into the release, with no connection to Kelynto. A changed, truncated or wrongly signed file is refused; an expired licence gives a grace period and then read-only, never data loss; a server clock set back by more than a stated tolerance is treated as a licence problem. Tested on a development machine. No signing key has been issued yet, so no licence file exists for any deployment today

  • Cloud-neutral path Implemented

    Docker Compose with an overlay for an existing PostgreSQL server. Executed locally end to end

  • Deployment-level lock on outbound lookups and language models Implemented

    Two settings forbid every signal lookup (KELYNTO_OUTBOUND_SIGNALS=false) and every language model call (KELYNTO_EXTERNAL_LLM=false) for every workspace, whatever its settings say. The private Azure parameter file and the AWS example set both; the settings screen shows them as locked and the onboarding check reports them. Executed in tests; not observed on a network

  • AWS deployment kit Enterprise implementation

    A Terraform module with the same shape as the Azure kit. Checked statically only; never initialised, planned or applied

  • A reference deployment in a customer's cloud account Not in place

    None exists. The Azure templates have been applied to one subscription, Kelynto's own, for its staging environment; no customer's subscription has one

  • Google Cloud deployment Not in place

    A mapping of components to services is written. No templates

  • Kubernetes or Helm deployment Not in place

    No chart or manifest is supplied

  • Marketplace listing or one-click install Not in place

    None. The honest path is a script in Cloud Shell or the compiled template in the portal, with manual steps before and after

  • Fully disconnected (air-gapped) operation Not in place

    Not supported as a tested configuration. The application must reach the customer's identity provider, and building images needs package registries

Vulnerability management

  • Pinned dependencies Implemented

    The API image installs exactly the versions in a lock file (exact versions; package hashes are not checked); the web build uses the package lock

  • Dependency audit, run by hand Implemented

    pip-audit on the lock file (45 packages) and npm audit on every JavaScript package reported no known vulnerability on 6 October 2026. A point-in-time result

  • Scans on every pull request and weekly Planned

    A workflow runs the security scan script on every pull request and push and weekly; both images are scanned for every change that touches them, as the gate of a deployment and weekly. They are linted, and have run on GitHub since October 2026, not yet as an operated process

  • Static security analysis of the Python code at zero findings Implemented

    ruff's security rules and bandit read the application code; any finding fails the scan. Run by hand on 6 October 2026: none in application code. False positives are suppressed in place, one rule per comment, and a test counts them. The engine package is read too and fails the scan only at high severity

  • Secret scan of the whole git history Implemented

    gitleaks reads every commit. Run by hand on 7 October 2026: four findings, two invented strings in a test, the published development key of a storage emulator and an invented provisioning token in a screen test, each ignored by fingerprint and by nothing broader

  • Scan of the built container images Planned

    Wired into both workflows, failing at high severity with a fix available. No result recorded yet: no Docker daemon on the build machine, and the image jobs first ran on GitHub in October 2026

  • Automated update proposals Planned

    Dependabot is configured for all four ecosystems. Not operating until the repository is hosted

  • Software bill of materials Not in place

    A bill of materials of the API image was produced by hand once (141 packages). It is not produced or published per release

  • Committed time to patch Not in place

    No commitment exists. Proposed targets are in the readiness list

  • Penetration test Not in place

    None performed. A scope is written

  • Vulnerability disclosure policy Planned

    Drafted. Not published. A security.txt that names security@kelynto.com as the contact is in the site build of 3 October 2026; that mailbox has to be created before the build is published

  • Base images pinned by digest Not in place

    Base images are named by tag, so a rebuild can pick up a changed image

  • Static checks of infrastructure code Implemented

    Bicep is linted, the Terraform module is scanned with checkov (288 checks passed, 13 skipped with a written reason each) and the Dockerfiles with hadolint (no finding on 6 October 2026). Run by hand

Secure development

  • Automated tests including isolation Implemented

    A backend suite on PostgreSQL covers tenant isolation, sign-in, authorisation, rate limits and retention; a test fails if a tenant table lacks a forced policy

  • Production-mode rehearsals Implemented

    The images are built from the real Dockerfiles and the stack is exercised end to end locally, with stand-in base images on machines that cannot pull

  • Threat model Implemented

    Assets, actors, trust boundaries, data flows, and per component each threat with the control that answers it, the test that shows the control refusing it, and the risk that remains. Written by the engineers who built the controls; not independently checked

  • Security review of new surfaces Implemented

    The public API, built-in sign-in, workspaces, invitations and sample workspaces were reviewed on 3 October 2026. Two High and four Medium findings were filed. The two High and three of the Medium ones were fixed by their owner the same day and re-tested by the reviewer by execution. The remaining Medium and three Low findings, on the assistant side, were fixed in release 2.3.0 and tested by their author; the reviewer has not re-tested those

  • Linters and static checks Implemented

    Ruff (with its security rules), bandit, the TypeScript compiler and ESLint for code; gitleaks for secrets in the history; shellcheck, hadolint, the Bicep linter, checkov, actionlint and zizmor for deployment code. The security checks run from one script that is also a pipeline job. Run by hand; results recorded

  • Claims are tied to evidence Implemented

    A script fails when a control marked Implemented names a file that does not exist, or when the published register differs from these pages

  • Continuous integration on every change Planned

    Workflows for tests, builds, scans and rehearsals are written and pass actionlint and zizmor. They have run on GitHub since October 2026

  • Pipeline actions pinned by commit Implemented

    Every third-party action in the workflows is pinned to a commit hash

  • Passwordless deployment from the pipeline Implemented

    The deployment workflow signs in to Azure with federated credentials (no stored cloud secret) and has deployed Kelynto's Azure staging environment on every merge to main since 27 October 2026, with health checks, a first-call check of the AI writer and automatic rollback of the application images. Production deploys only from a release tag after staging succeeded for the same commit; that gate has not been exercised

  • Mandatory review by a second person Not in place

    There is no second person and no branch protection

  • Written secure development policy and training Not in place

    Not written

  • Signed images and provenance Not in place

    Images are not signed and no provenance attestation is produced

  • Change management record Not in place

    Migrations carry a compatibility record and deployments have a validation record; there is no formal change approval process

Reviewing Kelynto for security or procurement? The security overview lists every known limit and how to get the review pack.

Open the security overview Deployment models Privacy notice for this website