Confidential computing is a security approach for protecting data in use: data that an application has already loaded into memory so it can process it. It uses a hardware-backed Trusted Execution Environment (TEE) to isolate selected code and data, then uses attestation to provide evidence about the protected environment before sensitive secrets are released to it.
This fills a specific gap. Encryption at rest helps protect stored files and disks. TLS helps protect data moving between systems. During ordinary processing, however, data must usually be decrypted in memory, where highly privileged infrastructure software may be in the trust boundary. The Confidential Computing Consortium describes confidential computing as protecting data in use through computation in a hardware-based, attested TEE. Its technical analysis explains the model and its relationship to other security controls.
The important word is reduce, not eliminate. A TEE can reduce the amount of trust placed in components such as a host operating system, hypervisor, cloud administrator, or a broader application process. It does not make unsafe application code safe, nor does it remove the need to decide who may access data and keys.
The basic idea: an isolated place to compute
A TEE is a protected execution boundary implemented with hardware support. Depending on the design, it can isolate an entire virtual machine or a smaller portion of an application. Code outside that boundary is intended to be unable to read or alter the protected memory directly. Microsoft’s TEE overview describes hardware-protected isolation of CPU and memory and distinguishes VM-level and enclave-oriented approaches. Read the TEE overview on Microsoft Learn.
That boundary changes the question from “Do I trust every privileged layer that hosts my workload?” to “Which components must I trust for this particular workload, and how can I verify what is running before it receives a secret?” The answer remains workload-specific.

How attestation and key release work
Attestation is the mechanism that lets a verifier assess evidence from a protected environment. The exact format and validation process vary by platform, but the security pattern is broadly similar.
- Start the workload. A VM or application component begins inside the selected protected environment.
- Measure the environment. Hardware and supporting firmware produce evidence tied to relevant attributes, such as the workload identity or configuration.
- Validate the evidence. A verifier checks whether the attestation is genuine and whether it matches an approved policy.
- Release a secret conditionally. If the policy passes, a key-management service or other trusted system can provide a decryption key, token, or credential to the attested workload.
- Process the data. The workload uses the released secret within the intended boundary, subject to the limits of its design.
Attestation is not simply a “secure” flag. It is useful only if the verifier has a meaningful policy. For example, a policy might allow a key only when the expected workload measurement is present, the environment is in an acceptable security state, and the attestation has been validated by the organization’s chosen trust process. The policy must also cover updates: an approved patch may legitimately change the expected measurement.
Confidential VMs versus application enclaves
“Confidential computing” covers more than one deployment pattern. The most useful distinction is the size of the protected boundary.
| Pattern | Protected boundary | Best fit | Main trade-off |
|---|---|---|---|
| Confidential VM | Most or all of one virtual machine | Existing workloads that need a broader infrastructure boundary with fewer application changes | A larger trusted workload and operating environment |
| Application enclave | A narrow, purpose-built component of an application | Protecting a particularly sensitive operation, such as handling a decryption key or a small PII-processing routine | More design, integration, and operational work |
A confidential VM is often the practical starting point when an organization needs to move a conventional service with limited code changes. An enclave can create a smaller trusted computing base because less code is inside the protected boundary, but it also forces the team to define careful interfaces between protected and unprotected code.
A trusted computing base (TCB) is the collection of hardware, firmware, and software components whose correct operation is necessary for the security property you rely on. A smaller TCB can be easier to reason about, but only if the integration is actually sound. The boundary and components are not identical across platforms; Microsoft’s discussion of confidential-computing TCBs is a useful illustration of why the exact design matters. See the Azure TCB discussion.
Three possible uses
These are architectural examples, not guarantees of security or compliance.
- A cloud service processing PII: A service processes customer records in a confidential VM. Storage encryption and TLS remain in place; the TEE adds protection intended to reduce exposure while records are held in memory.
- Cross-organization analytics: Several organizations agree on an approved analytics workload. Each contributes encrypted data, and a key-release policy supplies decryption material only after the expected workload has attested. Governance, output controls, and contractual rules still matter because an approved workload could produce inappropriate results if designed poorly.
- Attestation-gated decryption: An application keeps a data-encryption key in a key-management system. Rather than sending the key to any instance that requests it, the system releases it only after validating evidence for an approved workload. This reduces a class of deployment and infrastructure-trust risks; it does not prevent the approved application from leaking plaintext through logs or an insecure API.
What confidential computing does not solve
A protected execution boundary is not a substitute for the rest of a security program. If malicious code, a vulnerability, or an overly broad data export function runs inside the trusted workload, the TEE may faithfully protect that unsafe code while it handles the data.
- It does not replace encryption at rest or encryption in transit.
- It does not correct application vulnerabilities, unsafe logging, insecure APIs, or poor input validation.
- It does not decide which users, services, or administrators should have access.
- It does not remove the need for patching, monitoring, incident response, backups, and recovery testing.
- It does not eliminate key-management risk. Someone must define, protect, and operate the key-release policy.
- It does not make every infrastructure component irrelevant; hardware, firmware, attestation validation, and the code within the boundary still form part of the trust model.
Operational constraints can also be significant. For example, AWS Nitro Enclaves are a specific enclave implementation with isolated CPU and memory, no external network connectivity or persistent storage, and communication through a parent instance using vsock. Those constraints show why teams should evaluate the actual implementation rather than assume all TEEs behave alike. AWS documents the Nitro Enclaves model and its constraints.
A practical evaluation checklist
Start with a threat model, not a product selection. The following questions help determine whether confidential computing addresses a real gap in a workload.
- Identify the data-in-use risk: What sensitive data enters memory, and which privileged infrastructure layers are you trying to trust less?
- Choose the boundary size: Would a confidential VM provide a useful first step, or does a narrow enclave better limit the code that needs to be trusted?
- Define an attestation policy: Which workload identities, measurements, configurations, and update states are acceptable?
- Connect key release to verification: Ensure secrets are released only after the attestation workflow has been validated. Decide how keys are rotated and how an unhealthy workload is denied access.
- Document the TCB: List the hardware, firmware, provider services, operating-system components, application code, and validation services that remain trusted for the stated security goal.
- Test normal operations: Check networking, storage access, observability, debugging, patching, autoscaling, backup restoration, and disaster recovery before treating the design as production-ready.
- Review data outputs: Protecting input data in memory is not enough if the workload can return sensitive plaintext, write it to logs, or send it to an unauthorized destination.
The useful way to think about it
Confidential computing is a way to narrow a workload’s trust boundary while it processes sensitive information. Its value comes from pairing hardware isolation with attestation and a deliberate secret-release policy. It is most effective when the protected workload is small enough to understand, the remaining trusted components are documented, and conventional controls continue to protect data before, during, and after processing.
If the main concern is exposure of data in memory to privileged hosting layers, a TEE may be worth evaluating. If the underlying problem is insecure application behavior, weak identity design, or uncontrolled data exports, address those issues first or alongside it. The technology changes one important boundary; it does not remove the need for disciplined system design.

