Why open source LLM observability is becoming a record-keeping question
LLM applications are moving from pilots into production, and the teams running them now need traces, evaluations and cost data that they control. The main open-source options for self-hosted LLM observability are Langfuse and Arize Phoenix, and the choice between them turns on two things: the license terms and where the logs must physically live. Regulated organizations, platform engineering teams and compliance leads are the usual owners of this decision, and open source fits when the logs contain data that cannot leave your cloud account, data center or air-gapped network, or when you want the observability stack to be governed like any other internal system.
Logging is no longer only a debugging concern. Article 12(1) of the EU AI Act requires high-risk AI systems to technically allow for the automatic recording of events (logs) over the lifetime of the system, and Article 19(1) requires providers to keep those logs for at least six months unless other law provides otherwise. Traces of prompts, retrieved context, model versions, tool calls and user actions can become the evidence that an AI system behaved as documented. Whether your application is high-risk is a classification question for your legal and compliance team, so confirm it early, because it determines what must be recorded and for how long.
Before choosing a platform, ask three questions. Does your intended use of Langfuse or Phoenix involve offering it to third parties as a hosted service? Phoenix is licensed under the Elastic License 2.0, which prohibits providing the software to third parties as a hosted or managed service, while Langfuse is MIT licensed except its ee directories, so confirm the exact terms with counsel for your case. Where will traces containing personal data be stored, and who can read them? And who owns retention, deletion and access reviews once the platform is live? Answering these now avoids rebuilding the logging layer after an assessment.
What to agree on before choosing an LLM observability platform
Observability tooling is easy to install and hard to unwind once traces hold personal data. The decisions below set the scope, content, residency, retention, access and integrity requirements that any platform, including self-hosted Langfuse or Phoenix, must then meet. Settle them with legal, security and the application owners before comparing products.
Applications and providers in scope
List every application, agent, batch job and model provider that will emit traces, including internal tools and vendor-hosted features that call models on your behalf. Each one adds instrumentation work and a possible storage source. Gaps usually appear around embedded assistants and third-party SaaS that call models directly, so confirm those are included or explicitly excluded.
Content allowed in traces
Decide whether traces may hold full prompts, model outputs, retrieved documents, and user identifiers, or only metadata such as token counts, latency and model name. Full capture makes debugging and evaluation far easier but turns the trace store into a store of personal data. Many teams capture full content for a limited sample and redact identifiers at ingestion, which you should confirm the platform supports.
Data residency and hosting location
Confirm where trace data, backups and any queue or cache components may be stored, including regions for disaster recovery. Self-hosting keeps data in your own cloud account, data center or air-gapped network, but the database, object storage and analytics components each need the same placement rules. Record the location for every component so the answer holds up in a data protection review.
Retention periods by log type
Set separate retention for operational traces, evaluation datasets and records kept for accountability. The EU AI Act sets a minimum of six months for certain high-risk system logs, while general debugging data may need far shorter retention to limit exposure. Decide who deletes data when a retention period ends and how deletion is verified across backups.
Who can read traces
Define roles for developers, reviewers, security staff and external vendors, and decide whether trace viewers can see raw prompts or only redacted views. Map these roles to your identity provider so access follows joiner and leaver processes. Ask whether the platform supports project-level separation and audit records of who viewed or exported trace content.
Tamper-evident log requirements
Decide whether logs must be protected against alteration or deletion by administrators, which matters for incident investigations and regulatory evidence. Options include write-once object storage, hash chaining, separate audit accounts and off-platform copies. Confirm which of these your chosen platform supports natively and which you would need to build around it.
Langfuse, Phoenix and other options compared by license and fit
This table compares Langfuse and Arize Phoenix on license terms, internal versus customer-facing use, and day-to-day operating effort, with LiteLLM logging as a shared feed. Read the license row first, because it decides whether a platform can be offered to customers as a managed service, which the other rows then qualify. The main takeaway is that the choice often turns on licensing and existing skills rather than feature checklists alone.
| Factor | Langfuse | Arize Phoenix |
|---|---|---|
| License | MIT, except the ee directories, which are under separate terms | Elastic License 2.0, which prohibits providing the software to third parties as a hosted or managed service |
| Copyright holder | ClickHouse, Inc. | Arize AI project (confirm current ownership in the repository) |
| Internal use by your staff | Permitted under MIT for the non-ee code; confirm which features sit in ee directories before enabling them | Permitted under the Elastic License 2.0 for internal use; confirm terms with your counsel |
| Offering observability to customers as a managed service | Permitted under MIT for non-ee code; confirm ee-directory terms first | Not permitted to provide Phoenix to third parties as a hosted or managed service |
| Best fit | Teams that want a full tracing, prompt management and evaluation platform with a permissive base license | Teams focused on tracing and evaluation for internal use who accept the Elastic License terms |
| Operating effort | Plan for a database and storage tier, upgrades and retention settings; confirm the reference deployment with the vendor | Plan for hosting, upgrades and trace storage; confirm the deployment options and storage backend with the project |
| Shared logging input | Can receive traces from LiteLLM logging callbacks; confirm the integration version in your environment | Can receive traces from LiteLLM logging callbacks; confirm the integration version in your environment |
| Latest tagged version in our source notes | v4.63.0, published October 16, 2026 | Confirm the current release before planning |
What to log in each LLM request and what to leave out
Decide the logging schema before you deploy Langfuse or Phoenix, because retrofitting fields later leaves gaps in the records you may need for incident review or EU AI Act record-keeping. For each request, capture the model identifier and provider version, the prompt template name and version (not only the rendered prompt), the input and output payloads, latency, input and output token counts, the derived cost, a pseudonymous user or tenant reference, evaluation scores, and any human feedback signal. Those fields let you answer which model and prompt produced an output, for which tenant, at what cost, and how it was rated. Confirm in your version of each platform whether it records template versions natively or whether your application must pass them as metadata.
Raw prompts and completions are the largest privacy exposure in an observability store, because users routinely paste customer records, health details or credentials into chat. Store a stable pseudonymous user identifier rather than names or email addresses, and treat the trace store as a system of record with the same access controls, encryption and retention rules as the source application. Where raw content is not needed for a given purpose, log hashes, lengths or classification labels instead. Decide per application whether full payloads are kept, truncated, or dropped, and document that decision as part of your data protection assessment.
Redaction and sampling reduce both risk and storage. Redaction can happen in the application before data leaves it, in a collector or proxy in front of the platform, or inside the platform through configurable masking, and each location has different coverage. Sampling reduces volume by keeping a fraction of traces, but it must not drop every trace for a flagged user, error or high-risk workflow. Ask each vendor and your implementation partner to confirm which masking, filtering and sampling features your chosen release supports, how they behave on nested fields and attachments, and whether redaction is applied before or after data is written to disk.
Reference architecture components for self-hosted tracing
A self-hosted LLM observability stack is a small set of components that receive traces from applications, store them, run evaluations and expose them to reviewers under access control. Each component adds an operating responsibility, so the infrastructure team should agree on ownership before the first trace is sent.
Instrumentation SDKs and collectors
Application code or a gateway emits trace spans for each prompt, model call, retrieval step and tool call. Teams often pair the Langfuse or Phoenix SDK with an OpenTelemetry collector that sits inside the network boundary, so spans can be filtered or redacted before they leave the application tier. Check which fields carry user input, retrieved documents and personal data, because those fields define your retention and access scope.
Observability server
The web and API service receives traces, renders the trace explorer and hosts prompt versions and scores. Its license matters: Langfuse is MIT outside its ee directories, while Phoenix is under the Elastic License 2.0, which prohibits offering it to third parties as a hosted or managed service. Confirm with counsel whether your internal use or any service you run for a subsidiary or customer falls within those terms.
Backing databases and object storage
Trace data is written to a relational database for metadata and to analytical or columnar storage for high-volume span data, and large payloads often go to object storage. The infrastructure team owns sizing, replication, encryption at rest and the restore path. Ask the vendor for its current supported database versions and the expected write load per thousand daily requests before committing to a storage class.
Evaluation runners
Evaluation jobs replay sampled traces against rubrics, human labels or model-based judges and write scores back to the server. They need outbound access to the judge model, which may be a self-hosted endpoint or an external API, and they consume compute on a schedule separate from production traffic. Decide who approves judge models and whether evaluation data may leave the environment.
Access control and identity
Trace data often contains prompts, documents and customer details, so reviewer access should follow the same identity model as the rest of the platform. Configure single sign-on, project-level roles and an audit trail of who viewed or exported traces. Confirm which roles the chosen version supports and whether audit events can be forwarded to your SIEM.
Backup, retention and log integrity
Backups must cover both databases and object storage, restored together, or traces will point to missing payloads. Retention needs a documented period per use case, because Article 19(1) of the EU AI Act requires providers of high-risk systems to keep automatically generated logs for at least six months unless other law provides otherwise. Test restores on a schedule and record the results as evidence.
How to size storage and set retention for LLM traces
Storage growth for LLM traces is driven by five factors: request volume, the average size of prompts and completions, retained attachments such as uploaded documents or images, evaluation outputs (scores, judge model responses and annotations), and replication across environments or backups. Of these, token volume per request is the one teams most often underestimate, because agent workflows and retrieval-augmented prompts can carry far more context than the user's question. Before sizing anything, measure real token counts per use case in a pilot, separating interactive chat from batch evaluation runs, since the two produce very different trace profiles. Ask the platform team to confirm how the chosen tool stores full request and response bodies compared with metadata, and whether evaluation results are written to the same database or to a separate store. Those answers, not a generic estimate, should drive the storage budget.
Retention is where observability design meets legal duty. Article 12(1) of the EU AI Act requires high-risk AI systems to technically allow for the automatic recording of events over the system's lifetime, and Article 19(1) requires providers to keep the logs they control for at least six months unless other law provides otherwise. The six-month floor is a minimum, not a target, and it applies to a specific set of logs, so the first decision is to classify which traces fall under that obligation and which are operational debugging data. A practical approach is to keep a compliance-scoped log set with its own retention rule and access restrictions, and to apply shorter, data-minimized retention to full prompt bodies that may contain personal data. Confirm with your legal and compliance team whether your sector imposes longer periods, and check whether the EU AI Act Service Desk's Article 19 guidance matches your classification of the system.
Retention settings should be tested, not only documented. Run a restore and deletion test on a copy of the trace store to confirm that expiry jobs remove full bodies, attachments and evaluation outputs together, and that backups do not silently extend the retention period beyond what the policy allows. Decide who may change retention, who approves exceptions for litigation holds or incident investigations, and how that change is recorded. Ask the implementation partner to size the database, object storage and backup volumes from your pilot measurements, to state which costs are one-time (setup, schema and dashboard work) and which recur (storage growth, backup copies, compute for evaluations), and to show how the retention schema and expiry configuration will be documented as evidence for your assessment.
Build in-house, work with a partner or buy SaaS for LLM observability
This table compares running self-hosted Langfuse or Phoenix yourself, working with an implementation partner on open source, and buying a commercial hosted observability service. Read each row as a question to answer for your own organization, since data location, operating effort and recurring cost usually decide the choice. The main takeaway is that self-hosting shifts trace data, upgrades and backups onto your team or a contracted party, and that choice must be made before traces start containing prompts and user data.
| Decision factor | In-house operation | Open source with a partner | Commercial hosted SaaS |
|---|---|---|---|
| Where trace data lives | Your cloud account, data center or air-gapped network | Your infrastructure, with the partner working inside it under agreed access | The vendor's hosting region, confirmed in the contract and data processing terms |
| Who upgrades the platform | Your platform team tracks releases, such as the Langfuse v4.63.0 or Phoenix tagged versions, and tests them | Partner runs upgrades under the retainer or fixed scope you agree | Vendor performs upgrades on its schedule; confirm notice periods |
| Backups and restore testing | Your team designs, schedules and tests restores of the database and trace store | Partner designs backups; your team approves retention and restore tests | Vendor-managed; ask what you can export and how restores are verified |
| Operating effort | Ongoing time for monitoring, storage growth, access reviews and incident response | Lower internal effort, but still needs a named internal owner for prompts and evaluations | Lowest infrastructure effort, but your team still maintains instrumentation and evaluation logic |
| One-time cost | Architecture, deployment, integration with applications and evaluation setup | Scoped implementation, hardening and documentation, agreed in writing before work starts | Onboarding and instrumentation work, plus any integration with your identity and logging tools |
| Recurring cost | Compute, storage for traces, backups and internal staff time | Infrastructure plus retainer or support fees, which depend on scope | Subscription or usage pricing that scales with traces; confirm the unit and any overage terms |
| Licensing limits | Check whether the license allows your use, especially for Phoenix under the Elastic License 2.0 and any ee directories in Langfuse | Partner confirms license terms before deployment and tracks any change | Vendor license covers hosting; confirm data reuse rights and exit terms |
| Evidence for record-keeping | You define log schema, retention and access records; you produce the evidence yourself | Partner prepares log configuration and runbooks; you keep ownership of retained records | Vendor provides exports and audit features; verify they meet your retention period |
How a self-hosted LLM observability rollout runs
The sequence moves from agreeing what is worth recording to a monitored, access-controlled Langfuse or Phoenix instance that the client's own team can run after handover. Each phase closes with a written output, so scope, data decisions and operating ownership are settled before production traffic is traced.
Scope applications and classify the data
DeployOpen works with your AI product owners, security team and privacy lead to list the LLM applications in scope, the model providers they call, and the kinds of content they handle, such as personal data, customer records or internal documents. The output is a short scope document and a data classification register that states which prompts, responses, tool calls and metadata may be captured, which must be masked or excluded, and which systems hold a copy. The phase is done when the data owner signs off on that register.
Pilot instrumentation on one application
The team instruments a single application with the chosen tracing SDK or gateway callback, sending traces to a non-production Langfuse or Phoenix instance. The pilot checks that nested spans for retrieval, model calls and tool use appear correctly, that token counts and latency are captured, and that masking rules remove the fields the register excludes. The output is a pilot report listing what was captured, what was missing and what was changed. Confirm the exact SDK and integration path against the current documentation of the platform you select, since integration methods differ between Langfuse and Phoenix.
Decide schema, retention and sampling
Using the pilot report, the team fixes the trace schema: which attributes are mandatory, how users and sessions are identified without exposing direct identifiers, how model versions and prompt versions are tagged, and what sampling applies to high-volume traffic. Retention periods are set per data class, taking into account any minimum period your legal or regulatory obligations require. Where the EU AI Act applies to a high-risk system, Article 19(1) requires providers to keep automatically generated logs for at least six months unless other law provides otherwise, so confirm the retention position with counsel. Storage sizing follows from the sampled volume and retention. The output is an approved schema and retention schedule.
Build production hosting with access control
DeployOpen deploys the platform into your cloud account, data center or private network, with the database, object storage and application tier defined as code. Access is tied to your identity provider, with roles that separate engineers who debug traces from reviewers who see evaluation results and from administrators who manage projects. Encryption, network restriction, secrets handling and audit logging of administrative actions are configured and tested. Backups are scheduled and a restore test is run against a copy of the data. The output is a hardened production environment, an access matrix and a tested restore record.
Configure evaluations and alerting
The team defines the evaluations that run on traces, combining automated scoring, such as checks for policy violations or retrieval relevance, with human review queues for samples that need judgment. Alert thresholds cover error rates, latency, cost per session and evaluation failures, and route to the people who can act on them. Each evaluation is documented with its purpose, its input data and its known limits, so reviewers do not treat a score as a verdict. The output is a tested evaluation catalog and a set of alert rules with named owners.
Hand over operations and maintenance
DeployOpen delivers runbooks for upgrades, backup and restore, retention jobs, key rotation, onboarding of new applications and incident response, and trains the operators your team assigns. Upgrade paths are documented against the release notes of the chosen platform. The handover is complete when your operators have performed a supervised upgrade or restore themselves. Ongoing support, upgrades and continuous testing can be contracted as a retainer if you prefer to keep operations outside your own team. Ask any partner to state in writing who holds the on-call duty after handover.
Systems LLM observability must connect to
LLM traces are only useful when they tie back to who made a request, which model and gateway handled it, which code version produced it, and where incidents and evidence are kept. The six connections below determine how much of the observability platform's data can be trusted and reused in audits and investigations.
Identity provider for SSO
Trace views and prompt data must be restricted to the people who are allowed to see them, so the observability platform needs SSO through your identity provider, mapped to project and organization roles. Confirm whether the platform supports OIDC or SAML for your provider, how role mapping works, and whether API keys for SDK ingestion are issued per project and can be rotated without a redeploy. Check that user identity reaches each trace, otherwise accountability for a request is lost.
AI gateway and model providers
Traces are most complete when the gateway, such as LiteLLM, records the calling application, model, token counts and latency before the request leaves your network. Decide whether instrumentation sits in the gateway, in the application SDK, or both, so a single request is not counted twice. Confirm which provider metadata (model version, region, finish reason) is passed through, and whether cost fields are calculated by the observability platform or taken from the gateway.
Application code and CI pipelines
Each trace should carry the application name, release version and prompt template version, so a regression can be linked to a specific deployment. Evaluations should run in CI as well, with results written back to the platform as scores on a fixed dataset. Confirm the SDK languages supported, how prompt versions are stored and referenced, and whether evaluation runs can be triggered and retained from a pipeline without manual export.
SIEM and log archives
Security teams will expect LLM events in the same SIEM that holds application and identity logs, so correlation with authentication failures or unusual data access is possible. Decide which fields are forwarded, which are redacted before forwarding, and how long raw traces are kept in the platform compared with the archive. Confirm the export format and whether the platform can write to object storage with the retention and immutability settings your archive policy requires.
Ticketing for incidents
When an evaluation score drops or a user reports a harmful output, the trace link should move into the incident or change ticket without copying prompt content into email or chat. Define which events open tickets automatically, such as guardrail hits or score thresholds, and who triages them. Confirm whether the platform offers webhooks or alerting integrations for your ticketing tool, and whether links to traces stay access-controlled for people outside the platform.
Data stores for evaluation datasets
Evaluation datasets, including labeled questions, expected answers and reviewer scores, usually live in a separate store such as a data warehouse or object storage that already has owners and backups. Connect those stores to the platform as the source of truth and avoid making the observability database the only copy. Confirm how datasets are versioned, how personal data inside test cases is handled, and whether the platform's database backups cover traces and scores separately from those datasets.
Questions buyers ask before hiring help for LLM observability
What drives the cost and effort of self-hosted LLM observability?
Cost depends on how many LLM applications you trace, how much data each trace carries, how long you keep it, and how many evaluations you run on it. The main components are the infrastructure you run (compute, databases, object storage and backups inside your own cloud or data center), the implementation work (deployment, instrumentation of each application, evaluation setup and access control), and ongoing operations (upgrades, storage growth and on-call support). Infrastructure is recurring, while deployment and instrumentation are mostly one-time. Ask any partner for a quote that separates these lines, lists the applications in scope, and states the expected trace volume and retention period in writing so the estimate can be checked.
How long does a pilot take and what sets the timeline?
The timeline is set by scope, not by the tool alone. The biggest factors are the number of applications to instrument, whether they already emit traces, how many evaluators and dashboards the team needs, and how quickly approvals arrive for hosting, identity and storage. A pilot covering one application on existing infrastructure is usually much shorter than a multi-team rollout with SSO, retention rules and audit exports. DeployOpen agrees timelines in writing as part of a fixed-scope engagement, so ask for the phases, the client dependencies and the acceptance criteria before work starts.
What does the work need from our team?
Expect to provide several people with defined roles. An engineering owner needs to decide which applications are instrumented and how. Platform or infrastructure staff provide the hosting, database, object storage, networking and backup targets. Security and privacy staff decide what prompts and outputs may be stored, who may view them, and how long records are kept. A product or domain owner reviews evaluation criteria, because automated scores only mean something when someone defines what a good answer is. Agree on these roles early, because gaps in access or decisions are the most common cause of delay.
Can our internal team run LLM observability alone?
An internal team can run it alone if it already operates similar stacks, including Kubernetes or equivalent hosting, PostgreSQL or ClickHouse style databases, backups, identity integration and upgrade testing. The harder work is ongoing: keeping SDKs current across applications, tuning evaluations, managing retention and deletion, and responding to failures in trace ingestion. Ask whether your team has capacity for these tasks every month, not just at launch. Many organizations split the work, keeping day-to-day operations in-house while using a partner for setup, hardening, upgrades and documentation under a retainer.
Which license limits apply to internal use versus customer-facing use?
The license matters most when observability is part of a product you sell or host for others. Langfuse is distributed under the MIT License except for its ee directories, and Arize Phoenix is licensed under the Elastic License 2.0, which prohibits providing the software to third parties as a hosted or managed service. Internal use of Phoenix is generally a different question from offering it to customers, so have counsel confirm the exact terms against the current LICENSE file and your deployment model. Also check the license of any gateway or framework in the same stack, since terms differ across the ecosystem.
How do logs help satisfy the EU AI Act?
Article 12(1) of the EU AI Act requires high-risk AI systems to technically allow automatic recording of events (logs) over the system's lifetime, and Article 19(1) requires providers to keep those logs for at least six months unless other law provides otherwise. Observability tooling can capture the traces that support this, including model inputs and outputs, versions, timestamps and evaluation results, when you decide what to log. Whether your system is high-risk, and what your full obligations are, is a legal determination. DeployOpen prepares systems and evidence for compliance assessments but does not issue certifications or legal opinions.
What should we ask a partner before signing a scope?
Ask for a written scope listing each application, the trace fields captured, the retention period, the storage location, the access model and the evaluations included. Ask which license terms apply to the exact deployment you plan, how upgrades and backups are tested, and what the handover covers. Request the acceptance criteria and the client responsibilities in the same document. Good partners will explain what they will not do, such as issuing audit reports or guaranteeing model quality, so you can plan those tasks with your own assessors and reviewers.
What to ask an implementation partner before signing
Start with the license, because it decides what you can run and for whom. Ask the partner to confirm, in writing, which Langfuse or Phoenix version is in scope and which license applies to every component that will be deployed. Langfuse is MIT outside its ee directories, while Phoenix is under the Elastic License 2.0, which prohibits offering the software to third parties as a hosted or managed service. If your observability platform will serve a customer-facing product or a group subsidiary, ask for a written reading of that case before the design is fixed. Also ask how the partner will track version changes after handover, since the latest releases move quickly and a license review is only valid for the version reviewed.
Next, ask how traces will be classified and redacted before they reach storage. Prompts, retrieved documents and model outputs often contain personal data, so the partner should show which fields are captured by default, which are masked or dropped, and where that logic lives, whether in the SDK instrumentation, a collector or the platform itself. Ask who approves the data classification and who tests redaction with realistic but synthetic samples. Then ask for the retention design in writing. Article 19(1) of the EU AI Act requires providers of high-risk systems to keep automatically generated logs for at least six months unless other law provides otherwise, and Article 12(1) requires the logging capability to cover the system's lifetime. Your legal team should confirm which obligations apply to your system, and the partner should map each retention period to a specific store, a deletion job and an owner.
Finally, ask about operations and money. Request a backup and restore test with documented recovery results, not only a backup schedule, and ask whether the test covers the ClickHouse and object storage tiers. Ask how upgrades are handled, including who tests a new release against your instrumentation and who decides when to move. Ask who holds administrative credentials, API keys and database secrets at handover, and whether those are stored in your vault. On cost, ask which items are one-time, such as design, licensing review and initial deployment, and which recur, such as hosting, storage growth, support and upgrades. Require that every deliverable is listed with acceptance criteria in the fixed-scope document. DeployOpen provides quotes that follow from that written scope, so the scope should be complete before a price is discussed.
How DeployOpen scopes, builds and supports self-hosted LLM observability
DeployOpen is a Chainscore Labs company that plans, implements, hardens, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For LLM observability, we start from the tracing, evaluation and retention requirements your applications and compliance team actually need, then deliver a working self-hosted stack with the evidence to show how it was run.
How we scope
- Inventory the LLM applications, model providers and users that need traces, evaluations and monitoring
- Agree in writing which events, prompts, outputs and metadata are logged, masked or excluded
- Confirm log retention periods against your legal, contractual and EU AI Act record-keeping obligations
- Compare Langfuse and Phoenix licensing against how you intend to host and offer the platform internally
How we build
- Deploy the chosen observability platform in your environment with the storage and backup layout agreed in scope
- Instrument applications and gateways so traces carry the agreed fields, identities and correlation IDs
- Configure access control, encryption, and retention jobs, then test them against the written requirements
- Run evaluation and monitoring checks on representative workloads and record the results
How we hand over
- Deliver architecture, configuration, runbooks and a logging standard that your teams can maintain
- Document retention settings, access roles and how log exports are produced for auditors
- Walk your operations and security staff through alerting, incident handling and upgrade procedures
- Hand over under the terms of the written scope, with open items and owners listed explicitly
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer if you prefer not to run the stack alone
- Plan platform upgrades and schema changes with a rollback path and a test environment
- Review logging coverage as new models, applications and regulatory expectations arrive
- Prepare control evidence for your assessors, while audit reports and certifications remain with independent auditors

