> ## Content Index
> Fetch the complete content index at: https://devinside.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# JIT, ReadyToRun or Native AOT? Four .NET Release Decisions
- URL: https://devinside.cloud/how-dotnet-runs-11-the-release-memo/
- Published: 2026-11-21T15:00:11.000Z
- Description: Choose a publish mode for four .NET applications. Use the CLI, API and worker migration results to decide which gains justify a rollout and when to keep the old build.
- Author: Marcin Borecki
- Tags: Languages, Runtimes & Performance, Engineering Practice, .NET & C#, How .NET Runs Your Code, #Technology .NET, #Technology C#, #Technology ASP.NET Core, #Runtime JIT & AOT

[How .NET Runs Your Code](https://devinside.cloud/how-dotnet-runs/), part 11 of 11\. Previous, [Memory, Working Set and Heap Retention](https://devinside.cloud/how-dotnet-runs-10-memory-working-set-heap-retention/).

At the Intake 4.0 release meeting, Ravi asks Dana to “publish everything with Native AOT on .NET 11.” The operator tool, API and worker all built as native executables. The operations console has its own publish. The API answered its health check. The worker drained the queue and exited successfully. Lena, who maintains the partner export, opens the destination directory. There is no XML file.

Intake is a fictional team. The missing document is the result of running its published worker. Make the first call yourself. Pick a publish mode for the operator tool, the API, the worker and the operations console. Beside each choice, write down one observation that could change your mind. Keep those four guesses beside you. Later, try the same choices with one partner requirement changed.

- The same XML name survives two different writers. Whether you can replace one writer with the other depends on what the partner compares when the bytes arrive.
- The old native worker can exit zero, remove the job from pending work and leave the partner without a document. Check the delivered bytes and failed-export journal together.
- For sensor notifications, allowing up to eight concurrent single-file POSTs cut the earlier seconds-long wait and kept each retry to one file. [Compare parallel requests with batching on the EPYC](#transport-policy).
- The Linux rehearsal qualifies what the team can ship. The Windows comparison measures what changes when the same three framework-dependent applications move from .NET 10 to 11.

Working solution

### Intake 4.0 · How .NET Runs Your Code, parts 1 to 11

The full solution includes the completed release memo, a blank template, the four deployables and the original published-file tests. Part 11 includes the candidate matrix, complete file manifests, actual API responses, partner XML, MVC pages and acceptance reports for .NET 10 and .NET 11\. Debug and Release tests passed on macOS and Windows.

[Download the solution (zip)](https://devinside.cloud/content/files/2026/11/how-dotnet-runs-11-v9.zip)

how-dotnet-runs-11-v9.zip · 26.24 MiB (27,510,833 bytes) · tag articles/how-dotnet-runs-11-v9 · MIT license

## Find the operation that the green signal skipped

An ordinary publish carries managed intermediate language. The just-in-time compiler (JIT) produces instructions for methods at runtime. ReadyToRun adds precompiled method bodies and keeps the JIT available. Native ahead-of-time compilation (Native AOT) produces application machine code during publish. None of these descriptions tells Lena whether an XML reader can recover the job name. That question belongs to the consumer.

#### The inherited memo

Build succeeded. The health check returned 200\. The worker exited zero. Promote the native release to the fleet.

#### A release row someone else can check

On native Linux x64, publish the ordinary worker with its explicit writer. Submit `R&D <night>`, parse the resulting partner XML, and read the pending and failed queues. A missing file stops promotion even after a successful process exit.

The failed-export journal still contained job 1, its original name and the serializer error. The job disappeared from the pending queue when the worker reported that failure. Reading the two queues together explains why the supervisor could see a successful exit while the partner had nothing to open.

The worker made its success visible to the job supervisor before the partner had a usable document. Where is the equivalent point for an HTTP caller or the operator reading the console? Follow each operation to the person or program that consumes its result.

Architecture

### The consumer decides what each release row must prove

DeployableCLI · API · Worker · MVCPressureOne operation per rowDisqualifierOne missing customer resultProofOne named receiver per target

1. The same build pipeline produces four deliverables. Their owners wait for different things, and each needs a receiver where that operation can be observed.
2. The CLI can return the right policy answer and still lose a document. Test the fixed export vocabulary with the partner parser.
3. A valid acknowledgment gives no guarantee about the error writer. Exercise invalid submissions before and after a named job enters the journal.
4. Completing background work updates two systems. The partner document and the API journal must describe the same completed job.
5. The operations team uses an MVC view, which narrows the comparison to ordinary and ReadyToRun publishes before performance is considered.

Decision criteria from the four Intake operations. The complete memo is in `memo/RELEASE-MEMO.md`. The mixed Linux x64 receiver reports are under `results/linux/part11`.

That distinction changes what counts as proof of readiness. In [part 1 the same warning codes accompanied exports with different outcomes](https://devinside.cloud/how-dotnet-runs-01-what-a-publish-ships/). In [part 2 a process could announce readiness without calling the policy method](https://devinside.cloud/how-dotnet-runs-02-when-a-method-becomes-machine-code/). A green build and a ready listener are useful records. The question is which line they actually fill in the memo.

## Eight answers make the decision reviewable

Dana asks for the operation and its check, the features exercised, and the builder and receiver that supplied the result. Then she asks where the customer’s wait ends, what sustained work costs and what memory was observed. The last two entries reserve space for untested conditions and a reversal. A blank performance cell matters. Putting a laptop median in it would quietly change the machine, the workload or both.

The next four sections let you work through one choice at a time. If you already have your answers, open Dana’s memo and compare the reasons.

**Read the four release decisions for Linux x64**

The .NET 11 SDK built these self-contained folders on native Linux x64\. A second container on the AMD EPYC host verified each folder digest before launching its application. For the short-lived tool and worker, RSS is peak resident memory over their lifetimes. For the web processes, it is resident memory after the checked response.

| Deployable              | Operation, feature, receiver and wait                                                                                                                               | Steady work, memory, limits and reversal                                                                                                                                         |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Operator CLI](#tool)   | Parse three partner names from stdout.Bounded XML writer for a fixed vocabulary.Linux x64 native tool, c45ba6404dba.Launch to verified XML and exit.                | CPU per repeated invocation open.One export peaked at 28,401,664 B RSS.Other schemas and unqualified CPUs open.First missing name stops promotion.                               |
| [API](#api)             | Eight requests, including two invalid jobs.Generated description for the typed error.Linux x64 ordinary API, 95446072e0f4.Launch to first correct HTTP result.      | Production rate and tail open.RSS after the sequence was 69,156,864 B.Autoscaler traffic and fleet density open.Wrong status, body or journal state stops promotion.             |
| [Worker](#worker)       | One parsed XML file and no failed export.Captured rule plus explicit partner writer.Linux x64 ordinary worker, 65eba47c1205.From queued input to verified delivery. | Sustained CPU per delivered job open.One completed job peaked at 56,967,168 B RSS.Continuous arrival and rule diversity open.Missing file or unexpected failure stops promotion. |
| [Web console](#console) | First page shows the seeded failed job.MVC renders escaped HTML from API data.Linux x64 ordinary console, b70a358a63d4.From launch to the first correct page.       | Sustained traffic per instance open.RSS after the first page was 105,046,016 B.Other views and cold-page budget open.Missing reason or escaped name stops promotion.             |

The four memory cells come from one separate checked operation per app in `results/linux/part11/linux-x64/net11.0/mixed/residency.json`. The worker and MVC measurements exclude their separate API process. All four exclude the test process. Use the complete folder digests in `memo/RELEASE-MEMO.md` to find the matching run.

“Ship” in the Linux memo authorizes a canary, a limited deployment where the result decides whether rollout continues. The rehearsal establishes that the four deliverables work on the named machines. Before promising a faster service, Dana also needs a version comparison on the same hardware and a latency or capacity budget from the service owner.

[![The four-row release memo appears beside all four consumer.json files for the qualified Linux x64 mixed set.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s1-detail-fd142155535b_o.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s1-2x.webp)

Rider Each row points to the receiver operation that qualified its own published folder.

Ravi can also inspect the separately rehearsed fixed Mac set. Its report reads the original receiver results and checks their digests. The next screen shows what counts as a pass for each application.

Python · .NET on Apple silicon The report rechecks file identities and acceptance results for the fixed Mac set. Read each folder digest beside its own test count. [Full recording](https://devinside.cloud/content/media/2026/11/how-dotnet-runs-11-s2.mp4)

The original tests ran 460 cases across the four receiver environments and both runtime lines. All 56 deliberate failures matched the broken candidates they were intended to catch. Any other failure, or a pass from one of those candidates, would invalidate the rehearsal.

[![Rider shows all 13 fixed macOS artifact tests passing, grouped under the API, console, exporter and worker classes.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s3-detail-0e4fe5a1ec8a_o.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s3-2x.webp)

Rider The class counts show which public operation each group exercises. This session ran the four fixed macOS publications.

## The operator tool earns a bounded native package

An operator invokes `intake export` in a short-lived process. The partner expects a fixed `job/name` vocabulary. An empty input must produce a document containing an empty name. No output at all is a delivery failure. Similarly, XML escaping must change the representation of an ampersand or angle bracket while preserving the string the partner reads back.

### Which platform ships the smallest working tool?

Ravi can run the export on four kinds of agent. He wants the smallest installation that still produces a valid partner file. Each Native AOT tool passed the same three names with the explicit XML writer. Predict which target you would choose when the updater ships the executable alone. Would you choose it again if the support team also wanted the debugging symbols installed?

Measured

### The smallest executable and smallest installation come from different builds

| Target and host            | Executable | Whole folder |
| -------------------------- | ---------- | ------------ |
| Windows x64 on EPYC        | 5.18       | 24.72        |
| Linux x64 on EPYC (WSL 2)  | 6.24       | 17.93        |
| macOS Arm64 on M3 Max      | 5.63       | 25.59        |
| Linux Arm64 on M3 Max (VM) | 6.50       | 21.74        |

1. The updater distributes the program and stores symbols elsewhere. Compare only the executable column. Windows x64 needs the least space for this tool.
2. Support now needs the complete folder on each agent. The Linux x64 folder takes the least space even though its executable was larger.
3. Compare the two systems on the EPYC. The Windows debugging-symbol file alone is larger than the entire Linux x64 folder.

Uncompressed file sizes rounded to MiB from the four Native AOT CLI manifests under `results/{mac,win,linux}/part11`. Each receiver parsed all three expected names.

The Windows symbol file is `intake.pdb`. It occupies 20,459,520 bytes. The complete Linux x64 folder, including its native debug companion, takes 18,798,928 bytes. Put the symbol archive on a separate budget if that is how you deploy. If an operator has to run the command on a Mac, count the macOS build on that same basis.

The practical limit is the target set. The Mac, Windows and Linux packages each passed on their own receiver. The Linux candidate also needs its C library, loader and a supported processor. The exact floor in one ELF file cannot qualify another binary intended for an older machine. The release memo keeps physical Intel Mac and Windows Arm64 open. [Part 7 follows a package across that transfer](https://devinside.cloud/how-dotnet-runs-07-build-host-target-receiver/).

Ravi’s other reason to choose Native AOT was launch time. Compare fresh processes through valid XML and exit, using the same name and stated cache conditions. Only a difference measured over that operation gives him time he can multiply by the number of scheduled invocations.

### Would the same CLI pass a different partner check?

The ordinary tool and Lena’s smaller native tool have both exported the same job. The partner’s XML reader recovered `R&D <night>` from each file. Now imagine a migration checker that will accept a replacement only if its stdout matches the archived ordinary export byte for byte. Would you sign the same release row? Make your choice before moving the slider.

Worked example

### Two tools can agree on the job name and disagree on the bytes

Read the XML name Ordinary CLIR&D <night> Native CLI with the explicit writerR&D <night> Both pass the name check. 

1. The original partner parses the document. Both writers escape the punctuation and return the same characters to that reader.
2. The ordinary export includes an XML declaration, namespace declarations and indentation. The explicit writer emits the elements on one line.
3. The hypothetical checker compares every byte against the old output. Keep the qualified ordinary tool until the replacement passes that check or the partner changes it.

Linux x64\. Compare `cli-export-2.xml` in the ordinary and mixed CLI receiver results under `results/linux/part11`. The migration requirement is hypothetical.

Look at what changed your answer. The target machine and the published files stayed the same. The new requirement made the old stream’s formatting observable. The two saved streams even have different lengths, so a byte-for-byte check must fail. To check the original partner’s requirement, you still have to parse the name.

## The API has two response contracts and one journal

Start an empty API and post an unnamed job. The registered candidate returns 400 with a structured error and still has an empty journal. Submit `rebuild-index` and the response is 202 with `Location: /jobs`. Its ID and name agree with the next GET. A second unnamed submission must again leave exactly one recorded job. That last read catches an implementation that returns a plausible error after making an unintended write.

Hold the native build mode fixed and remove only the generated description of the error type. Health still succeeds, and the valid acknowledgment still works. Both invalid submissions now return 500 with empty bodies. The absence of a coded warning on this build did not make the error path safe. The fixed native alternative passed the same eight operations as the chosen ordinary API. [Part 6 opens the warning and the missing response type separately](https://devinside.cloud/how-dotnet-runs-06-trimming-reflection-warnings/).

Why ship the ordinary API for this canary? The service owner needs a usable diagnostic path as well as a correct response. In the separate part 10 retention specimen, 2,000 reads left 64 correct queued jobs but kept 2,000 completed snapshot views alive. Unsubscribing at response completion removed the view rows from the next collection. Those are two variants of the diagnostic specimen. Inspecting them identified a risk in a proposed design. It did not establish a leak in this release’s API.

A first-response claim needs another kind of evidence. On the instrumented .NET 11 Mac JIT path, 248 JIT-start events had accumulated by listener readiness and 706 by the first acknowledgment-writing mark. Those counts locate work but do not time it. The receipt that tells the customer the job exists comes later than the listening line. Part 8 preserved a control that rejected an acknowledgment naming the wrong job, despite its 202 status. For a real scale-out decision, keep that consumer check attached to every timed sample. [Part 8 defines the first correct response](https://devinside.cloud/how-dotnet-runs-08-startup-first-response/).

## A drained queue can conceal a lost document

Lena’s worker receives the current customer limit, builds an expression tree once and evaluates the rule for jobs. In the chosen managed build the runtime can compile the captured predicate. The explicit writer then exports the known partner shape. Setting `BoundedExport=true` changes the writer. The production worker still calls `PayloadRule.FromLimit` for the captured-field expression.

In [part 5](https://devinside.cloud/how-dotnet-runs-05-native-aot-code-built-after-publish/), a Native AOT probe put the numeric limit in an `Expression.Constant` node. The interpreted comparison allocated 184 bytes per call on the Mac. A source-written comparison returned the same decisions with zero bytes allocated per call. The release worker captures a field instead. Measure that expression before charging 184 bytes to every export.

Lena needs a test that fails for the original serializer and also detects an unrelated problem, such as a failure recorded against the wrong job. Which pieces of the worker’s result must agree before the rehearsal can identify the expected fault?

Code walkthrough

### A zero exit can accompany a missing partner file

```python
file = Path(tmp)/'1.xml'
raw = file.read_bytes() if file.is_file() else b''
(output/'worker-partner.xml').write_bytes(raw)
failures = json.loads(http(url,'GET','/exports/failed',200))
pending = json.loads(http(url,'GET','/work',200))
good = proc.returncode == 0 and parsed_name(raw) == name and pending == [] and failures == []
known = (proc.returncode == 0 and not raw and pending == [] and len(failures) == 1
         and failures[0].get('id') == 1 and failures[0].get('name') == name
         and 'error generating the XML document' in failures[0].get('reason',''))
```

1. The partner finds no file at the expected path in the broken run. The test records empty bytes internally so it can compare both outcomes.
2. Checking both API routes distinguishes a successful delivery from a failed export that was already removed from pending work.
3. The negative control must match the job identity and the serializer error as well as losing the document. A different red result fails this rehearsal.

tools/part11.py, consumer(), workers only. Launch, setup and the returned report are omitted. Actual rows and XML bytes are in the mixed and negative Linux x64 worker consumer receipts.

Both the ordinary worker and its bounded native alternative delivered the right name. Suppose Ravi wants to halve worker CPU per delivered document by replacing only the rule evaluator. Before writing a faster rule, what would you want to see in a profile?

Split worker CPU per correct export into the share spent evaluating the rule and the share spent everywhere else. Imagine making the evaluator free. Parsing the input, writing XML and acknowledging the job would still use CPU. If that remaining work already costs more than half the original total, even a free rule cannot halve the total.

This is the reasoning behind Amdahl’s law applied to one worker change. Hold the job mix and the rest of the work fixed. A CPU profile of representative exports can estimate the share worth pursuing. Use an on-CPU profile so that time a thread spends asleep waiting for I/O does not count towards the evaluator’s share. Then compare whole-process CPU per correct file on the original and changed workers. Switching the entire publish mode can change other costs too, so that comparison needs its own run. Intake’s functional trials identify the completed files. The rule’s CPU share remains unmeasured. [Gene Amdahl on the work left unchanged](https://doi.org/10.1145/1465482.1465560?ref=devinside.cloud). [Part 9 defines how to measure CPU per completed job](https://devinside.cloud/how-dotnet-runs-09-steady-state-jit-vs-native-aot/).

Memory observations also have an endpoint. In a different Linux x64 experiment the bounded ordinary worker produced 64 independently verified XML files under a 512 MiB cgroup limit. At two CPUs Docker displayed 13.41 MiB after that batch with input still open. In the final mixed rehearsal a fresh worker drained one job and exited. The operating system recorded a peak RSS of 56,967,168 bytes for that child. A post-batch container reading and a process lifetime maximum answer different questions. Dividing a node limit by either one would produce a replica count the experiment never exercised.

## The web console removes one choice before measurement

The operations console uses ASP.NET Core Model-View-Controller (MVC) and a Razor view. MVC is outside Microsoft’s supported Native AOT feature set. The release matrix records that combination as inapplicable. It has no native file size, no zero-time startup and no native acceptance result. The two applicable choices here are an ordinary publish and a ReadyToRun publish. [Microsoft’s ASP.NET Core compatibility table](https://github.com/dotnet/AspNetCore.Docs/blob/main/aspnetcore/fundamentals/native-aot.md?ref=devinside.cloud).

Dana’s check seeds `R&D <night>` and the reason `partner offline` through the API, then starts the published console. The first GET must render the failed job. The client checks the heading, the escaped HTML name and the reason. A 200 response from a shell page would miss the operation that drew a human to the console in the first place.

Compare this with your fourth guess. Both supported publish profiles passed. The ordinary Linux x64 .NET 11 folder contained 111,434,635 bytes. The ReadyToRun folder contained 111,515,019 bytes. The team operates a small number of console instances in this case. Without a measured first-page budget violation, Dana keeps the ordinary package and retains the ReadyToRun profile for a repeat with the same seeded page. [Part 4 opens the code that the JIT can still replace](https://devinside.cloud/how-dotnet-runs-04-readytorun-precompiled-code/).

Check two settings in the following captures. The CLI’s native compiler and explicit writer are independent choices. The MVC profiles vary only their use of ReadyToRun in this comparison.

[![The rehearsal driver selects MSBuild properties above the recorded build properties for the mixed Linux CLI.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s4-detail-0df3dcc1afca_o.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s4-2x.webp)

Rider The sender manifest records the driver’s choices. The mixed CLI has PublishAot and BoundedExport enabled.

[![The two self-contained MVC folders target Windows x64. Their profiles show the ReadyToRun checkbox clear and selected.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s5-detail-a2cd48119bca.webp)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-s5-2x.webp)

Visual Studio Insiders Both MVC profiles target the same Windows receiver. Enable ReadyToRun compilation is clear in Ordinary and selected in ReadyToRun.

## Both runtime lines reach the same support date

“Stay on long-term support” sounds like a calendar decision. Put the actual dates on the memo. .NET 10 began its three-year LTS window on November 11, 2025\. .NET 11 began its two-year standard-term support window on November 10, 2026\. On the November 21, 2026 reference date, Microsoft listed November 14, 2028 as the end of support for both. Both release lines require staying current on patches. [Microsoft’s support policy](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core?ref=devinside.cloud).

The rehearsal pinned 10.0.15 and 11.0.0\. Both lines passed on the named modern receivers. Dana names 11.0.0 for this canary because it is the specific mixed release whose operation, tool support and receiver observations she is reviewing. The .NET 10 counterpart passed the same functional checks. The calendar offers no extra remaining year for choosing 10 at this point, and the functional checks offer no evidence that 11 starts faster.

An existing .NET 10 fleet might still have a reason to stay put. The .NET 11 x64 JIT and AOT minimum is x86-64-v2\. The .NET 10 ordinary feature probe ran under an older emulated CPU model, although the .NET 10 native probe failed there. A runtime label alone cannot qualify an operator workstation. Inspect the actual CPU and run the actual delivered tool where it is supposed to work. [.NET 11 hardware requirements](https://learn.microsoft.com/en-us/dotnet/core/compatibility/jit/11/minimum-hardware-requirements?ref=devinside.cloud).

### Would you move the worker from AMD to Intel?

The Linux x64 run on the EPYC delivered a document the partner could read. The portable arithmetic probe used a wider addition on the Xeon W-2295 than on the EPYC, and both returned the expected sum. Which piece of work still needs a test on the Xeon? Run the actual worker there, send the escaped job name, parse the partner file and inspect the journal. That qualifies a second candidate for the same job. [See the JIT listings for the arithmetic probe](https://devinside.cloud/how-dotnet-runs-02-when-a-method-becomes-machine-code/).

For a purchasing decision, agree on the arrival rate and maximum acceptable p95 wait first. On quiet receivers, replay the same job mix and count verified deliveries. Reject a candidate if the measured p95 exceeds that limit or if it loses a document. For each eligible deployment, divide its cost for the run by the number of verified exports in that window, then multiply by 1,000\. That gives Ravi a price per thousand delivered files. A CPU instruction count, even for a real hot loop, supplies neither the bill nor the number of files the partner received. The arithmetic probe and the original canary contain no such cost comparison.

## Measure the unit that the release really carries

Ravi’s pipeline can answer a concrete cost question today. How many uncompressed bytes does each complete release folder occupy? Compare two complete sets in the same unit on the same receiver. The fixed set also changes the writers, so its values are the cost of packaging those working combinations.

| Application  | Ordinary (MiB) | Fixed (MiB) |
| ------------ | -------------- | ----------- |
| Operator CLI | 80.25          | 17.93       |
| Intake API   | 106.27         | 34.24       |
| Worker       | 106.30         | 29.52       |
| MVC console  | 106.27         | 106.35      |

Each figure includes the files actually present after one publish on Linux x64\. The fixed set uses native builds for the CLI, API and worker, plus ReadyToRun for the MVC console. Compare the `ordinary` and `fixed` sender manifests under `results/linux/part11/linux-x64/net11.0` to see which files enter each total.

Those Linux packages carry their own runtime. A runtime security fix therefore means rebuilding and qualifying each affected application. Ravi also maintains Windows agents where operations installs the shared runtime centrally. On those agents he can compare smaller, framework-dependent packages.

### What does the move from .NET 10 to 11 actually save?

Take Native AOT out of this decision. Publish the same CLI, API and worker for Windows x64 in Release with the ordinary JIT and the same application settings. The updater copies the full application directory, including symbols. What would you inspect first if all three directories got smaller?

| Application folder | .NET 10 (bytes) | .NET 11 (bytes) |
| ------------------ | --------------- | --------------- |
| CLI                | 220,308         | 133,799         |
| API                | 294,905         | 210,139         |
| Worker             | 326,689         | 243,299         |

Open the Windows file lists under `results/migration/builds` in the download. The SDK supplies a small native launcher called the *apphost*. It is already on disk before a JIT compiler sees the application. All three .NET 10 launchers occupied 162,304 bytes apiece. Their .NET 11 counterparts occupied 73,728 bytes apiece. The other files partly offset that saving. For an agent that receives all three uncompressed directories, the upgrade removes **254,665 bytes** from the application delivery. If the agent first needs the .NET 11 shared frameworks, add their installation to the rollout budget before promising a bandwidth saving. [Microsoft’s guide to framework-dependent publishing](https://learn.microsoft.com/en-us/dotnet/core/deploying/deploy-with-cli?ref=devinside.cloud).

That settles the updater’s question. To sign a performance claim, Dana needs a different row in the memo. For the [CLI](https://devinside.cloud/how-dotnet-runs-08-startup-first-response/), write the time the operator waits for a valid export. For the [API](https://devinside.cloud/how-dotnet-runs-09-steady-state-jit-vs-native-aot/), write the offered request rate, how many requests succeeded, and the wait at the 99th percentile. For the [worker](https://devinside.cloud/how-dotnet-runs-10-memory-working-set-heap-retention/), write CPU time per delivered file and the time the process spent paused for GC. A smaller launcher alone cannot fill any of those cells.

Ravi ran both versions on the same AMD EPYC workstation while its other services continued working. The six Windows pairs give Dana a reason to try .NET 11 on the worker, even though they give her no reason to remove a worker instance. CPU per correct file fell in five pairs and tied in one. The median paired reduction was 14.1%. Yet the same six pairs delivered between 6.4% fewer and 8.1% more files per second on .NET 11\. A team paying for CPU should test the saving on a canary. A team facing a growing queue should keep its current capacity until it measures faster delivery. For the [API at 50 scheduled requests/s](https://devinside.cloud/how-dotnet-runs-09-steady-state-jit-vs-native-aot/#migration-api-deadline), both servers acknowledged every request the client sent. The client missed slots on both versions. Dana would first change how traffic reaches the API before buying more server capacity.

Consider an incident after a deployment. On macOS Arm64 the native retention experiment produced heap totals without managed type rows. On Windows the Native AOT dump collection actually wrote a file, but the subsequent analysis reported `No CLR runtime found`. On the tested Linux targets collecting the managed dump was refused. Keep the ordinary diagnostic alternative buildable, identify the receiver and record which question the available tool can answer. [Part 10 distinguishes resident memory, heap totals and surviving objects](https://devinside.cloud/how-dotnet-runs-10-memory-working-set-heap-retention/).

## Keep the alternative runnable when the memo changes

A reversal needs an owner, a visible trigger and a candidate that has already passed the same check. Look at where the publish properties enter the actual build. The rehearsal selects a mode per application, records the resulting property values and sends the same fixture to the published paths. No source edit is required to get the ordinary alternative back.

```json
{
  "Worker": {
    "candidate": "worker-mixed",
    "mode": "jit",
    "writer": "bounded"
  }
}
```

The fragment is the worker entry of the primary mixed plan. It chooses JIT with the explicit writer. The adjacent API entry in the full JSON registers the error type. In the negative plan the worker uses its original native serializer, and the API omits that specific type. Rehearsing both directions keeps the cause visible when several applications share the same libraries.

### Would you ship the alarm policy that finishes the most files?

Suppose Lena needs at least 99% of files to produce a checked alarm line within 100 ms of becoming readable. Each comparison below uses four runs of 32 files per policy. Across those 128 files, one late alarm meets the example target and two break it. Dana times the first verified output for each file and keeps every missed deadline in the count.

On Windows with the EPYC, starting one process per file missed 118 of 128 deadlines during the 8 ms arrival trace. Draining up to eight ready files immediately missed none. The p99 fell from 1,095 to 79.2 ms as the checked rate rose from 24.6 to 102.6 alarms/s. For files arriving 120 ms apart, a 40 ms hold left two of 128 alarms late on the M3 Max and 18 of 128 on the Xeon. Immediate draining missed none on either host. Dana can try that policy on the Windows job and rule out a common 40 ms hold for these sparse workloads. [Compare the timing policies in part 8](https://devinside.cloud/how-dotnet-runs-08-startup-first-response/#temperature-arrival-policy).

Try an interruption after the first alarm has been saved. Three small CSVs produce hot counts of 1, 2 and 3\. A separate consumer checks all three outputs and writes the first pending notification to a SQLite **outbox**, a table of work for a sender. It exits before acknowledging the first input. The unacknowledged files are offered again. How many pending alarms should the sender now find?

**The append-only consumer queued four alarms for three inputs.** The first sensor was queued twice. The second consumer committed the immutable input ID and its outbox row in the same transaction. A retry found the existing ID and content digest, kept the first row and finished with three pending alarms. In a separate run, a malformed middle file stopped the importer after one good result. Isolating that file let the valid third input finish.

Repeat the interruption with the command in `results/temperature-arrivals/recovery/README.md`. An unexpected duplicate or missing input stops the rollout. The local sender can now find each pending alarm. Lena still needs her own service to have a saved notification for each input. [SQLite transaction guarantees](https://sqlite.org/transactional.html?ref=devinside.cloud).

## Did the notification service save the alarm before the connection closed?

Lena opens the notification inbox. Intake reported no reply to its last request. Her service might already have saved the alarm, or the connection might have closed just before the write. Retrying will help in one case. What would make the same retry safe in the other?

A producer renames a completed CSV into the inbox. A running .NET 11 sender reads its 37 temperatures and posts the file’s event ID and hot count to a separate HTTP service. That service inserts a notification into SQLite and marks the time as soon as `COMMIT` returns, before sending the response. Its database uses a write-ahead log with `synchronous=FULL`. After each run, an independent reader reopens it and matches every row to the input files. [SQLite’s commit settings](https://www.sqlite.org/pragma.html?ref=devinside.cloud#pragma%5Fsynchronous).

The sender and recipient first ran as separate processes on the same machine, where both endpoints share the system’s monotonic clock. Dana repeated the experiment on M3 Max, EPYC and Xeon. Their producer scheduled four files 3 ms apart every 160 ms. Each combination of fault and policy used four runs of 32 files, each with a fresh database. The sender had made one preflight request. Every file and its HTTP POST were timed, using a fresh TCP connection per POST.

Read the chart for the policy you would ship. *Send once* makes one attempt. *Retry append* makes one further attempt after a lost connection and the recipient appends a row for each successful insert. *Retry keyed* makes the same retry and the recipient looks up the original row by event ID. When the receiver closes the connection after the commit, which policies can still show a p99 for both the saved notification and the caller’s checked acknowledgement?

[![Time from file availability to the first committed notification and to its checked acknowledgement on M3 Max, EPYC and Xeon. Closing the connection can leave a saved row with no confirmation.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-delivery-latency-18e058ce4deb.svg)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-delivery-latency-18e058ce4deb.svg)

The p99 across 128 files is the 127th result in time order. If only 112 files reached an endpoint, the remaining 16 have no observed time there. The complete-input p99 is unreached. The download also reports timings for the files that reached it.

Follow one affected file on the EPYC. Event `sensor-008` contained 11 readings above 85 °C. The keyed receiver committed row 8 at **1.53 ms** after file arrival, then closed the connection without returning an HTTP status. Intake waited 12 ms and sent the same ID again. The receiver returned that original row ID, and the caller verified it at **18.99 ms**. Only one row for the event survived reopening. Across the 16 affected files on this host, the median wait from first commit to confirmation was about 15 ms. Those two timestamps belong to the same file.

Now look at the counts. Each fault struck the first attempt for every eighth file, the last file in alternate bursts. The receiver closed the connection before inserting any row in one trial and just after committing the row in another. The sender saw a closed connection in both. Which missing replies should Lena count as lost notifications?

[![Missing expected notifications, extra saved rows and outcomes the sender could not confirm. Repeating plain inserts after lost replies adds rows, while keyed retries recover the existing rows.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-delivery-outcomes-a2a83cc9a730.svg)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-delivery-outcomes-a2a83cc9a730.svg)

A missing notification is an expected input ID absent from the reopened database. Each extra row for the same input counts as one duplicate. An unknown outcome means the caller never verified a positive reply. The counts use each 32-file input list and its corresponding database.

With one attempt, 16 outcomes stayed unknown to the sender in either fault. Closing before the write left 16 notifications missing. Closing after the write left none missing. For the before-write case on EPYC, the 112 saved notifications alone had a p99 of 48.1 ms. Quoting it for all 128 files would hide every loss.

Retrying an ordinary insert recovered the missing files after a before-write failure. After a lost reply it produced 144 rows for 128 inputs. The keyed recipient kept one row per input in both trials. On a repeat it checked the hot count against the existing row and returned its ID. In a separate control, reusing an ID with a different count returned HTTP 409\. For your own notification, decide which fields have to agree before a repeat may succeed. [HTTP’s rule for retrying a request after a connection failure](https://www.rfc-editor.org/rfc/rfc9110.html?ref=devinside.cloud#section-9.2.2).

Across the three same-machine experiments, the recipient databases contained 3,456 rows for 3,456 input deliveries. Matching IDs within each run exposed 48 missing notifications and 48 duplicate rows. For a canary, reconcile the input IDs with the saved rows and keep the unknown outcomes available for lookup. A later retry can still fail, so give it a deadline and an owner. The saved notification is the measured endpoint here. Measuring a person’s wait would require a further timestamp at their device. [Part 8 shows why moving the finish line changes the latency result](https://devinside.cloud/how-dotnet-runs-08-startup-first-response/#file-to-durable-notification).

To reproduce a lost reply on your own machine, open `bench/temperature/NotificationDelivery` in the download and choose a new output file. In the resulting JSON, find `sensor-008` in `rows` and match its `ack_row_id` to the `row_id` in `stored`. The full timings and the figures’ source data are under `results/temperature-delivery`. On Windows, use `py -3` for `python3`.

```bash
python3 -m zipfile -e ../notification-kit.zip kit
python3 delivery.py kit/NotificationDelivery.dll --policy keyed --fault after --block 1 --out keyed-after.json
```

### Where does a file spend its time when the database is on another machine?

The M3 Max now sent each keyed request through an established SSH tunnel to the EPYC on Windows. Only the receiver could timestamp its database commit. The two machines’ monotonic clocks have different origins. Twelve clock probes before and twelve after each run bounded each save on the sender’s timeline, assuming their clock rates differed by at most 0.1%. Read the interval for the save, then the point for the reply timed entirely on the sender.

[![File arrival on M3 to the first committed row on Windows EPYC. Clean p99 lies between 5.919 and 6.076 seconds. With the scheduled lost replies it lies between 7.464 and 7.580 seconds.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-delivery-interhost-89c38b851e4a.svg)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-delivery-interhost-89c38b851e4a.svg)

The interval reflects the uncertainty in mapping the recipient’s clock to the sender’s. It covers the file-to-save p99 for the measured messages. Each of the two trials saved all 128 expected notifications.

On this route, file-to-save p99 was between 5.919 and 6.076 s in the clean trial and between 7.464 and 7.580 s when the receiver dropped the first reply for 16 of the 128 files. Why seconds? Files arrived at 27.5/s, but the serial sender confirmed 5.14/s in the clean windows and 4.59/s with the dropped replies. A file arriving while the sender was busy waited behind earlier files. In the dropped-reply trial the p99 from dispatch to checked acknowledgement was 534 ms. From file arrival to the same acknowledgement it was **7.61 s**. All 16 retries returned the previously saved row. The measured clock bounds and counts are in `results/temperature-delivery/interhost/summary.csv`.

## Which HTTP policy cuts the EPYC’s 7.6 s notification delay?

A sensor CSV becomes readable on the M3 Max. Lena needs its notification committed to SQLite on the Windows EPYC. Four new files can arrive while the sender waits for one reply. HTTP keep-alive reuses a forwarded TCP connection inside the running SSH tunnel. The sender still waits for a round trip per request. Would Lena gain more by sending the next file while that reply is on its way or by putting the whole burst in one request?

The previous serial run took about 7.6 s at p99 with lost replies. Dana reran it alongside five alternatives. Each run offered eight bursts of four files. Within a burst, files arrived 3 ms apart. The next burst started 160 ms after the previous one. That gives about 27.5 files/s between the first and last file of a run. Repeating the bursts indefinitely would average 25 files/s.

Start with one request at a time, first over a fresh connection and then over a persistent one. Next allow four or eight single-file requests in flight. The two batching policies also reuse connections. They allow one or four requests in flight, each carrying up to four files. The sender gives the oldest file 10 ms from admission to collect neighbors. If every request slot is busy, that file can wait longer for dispatch. [How HTTP reuses a connection](https://www.rfc-editor.org/rfc/rfc9112.html?ref=devinside.cloud#section-9.3).

The EPYC opened a SQLite connection for each POST and used one transaction for the whole request. In the lost-reply trials it committed the first request containing every eighth file, then closed the HTTP connection before returning any reply. The sender waited 12 ms and retried the same request body once. Read the range for the first save, then the dot for the reply. Both waits include the time the file spent in the sender’s queue.

[![File arrival to the first durable save and to the checked reply for six HTTP policies with dropped replies, from one fresh connection per file to four concurrent batches.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-transport-latency-0a7a94d2f73e.svg)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-transport-latency-0a7a94d2f73e.svg)

Each policy contributed 128 files across four databases. Clock probes bracket the 127th file-to-save time assuming the two clock rates differ by at most 0.1%. The reply uses the M3 clock alone. Each equal step on the horizontal scale represents a tenfold change in time.

In the new runs with lost replies, opening a fresh connection per POST put first-save p99 between **2.132 and 2.206 s**. The median clock-probe round trip was 76 ms here and 160 ms in the earlier 7.6 s trial. Use the new serial result to judge the five alternatives. Reusing connections cut 144 TCP connections to 20 for the same 144 POSTs and brought first-save p99 below 704 ms. Even then the sender confirmed only 16.7 files/s from first arrival through final drain.

With four single-file requests in flight, p99 time waiting for first dispatch fell from 667 to 51 ms. With the limit raised to eight, at most five requests overlapped. The wait fell below 20 ms and file-to-confirmation p99 reached 166 ms. Batching changed how much work the receiver handled. Four slots for batches needed only 33 initial POSTs and 16 retries for all 128 files. File-to-first-save p99 was **58 to 125 ms**. One batch at a time needed 32 initial POSTs plus 16 retries and reached 60 to 133 ms. The save intervals overlap. With four slots, the sender could dispatch a later batch before it received the earlier batch’s retry acknowledgement.

Follow `sensor-008` again. This time its first request also carried sensors 005, 006 and 007\. The recipient committed rows 5 through 8 together. Only sensor 008 triggered the connection close. Without a reply the sender had to retry all four IDs. Count the rows those four files should occupy when the retry succeeds.

[![Missing file IDs and extra durable rows for parallel batches. Losing a reply and retrying a batch adds duplicate rows when the recipient appends on every request.](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-transport-integrity-077ed4aeeeb5.svg)](https://devinside.cloud/content/images/2026/11/how-dotnet-runs-11-notification-transport-integrity-077ed4aeeeb5.svg)

Each panel compares the 128 expected inputs with the contents of their reopened databases. A missing ID counts a lost file. Every further row for an existing ID counts as a duplicate. The lost-reply count is per HTTP request.

The keyed recipient returned rows 5 through 8 on the retry. In the append-only trial the identical four-file body created rows 9 through 12\. In both trials the caller eventually checked four successful receipts. To trace it in the download, find `sensor-008` in `results/temperature-transport/joins.csv`. Select `batch4x4`, `after` and block 1, then compare the reopened row IDs for the two stores.

Across the six policies, both clean and lost-reply runs saved and confirmed every one of the **1,536 keyed inputs**, once each. In the append-only control all 128 inputs also reached the recipient, yet 16 lost POST replies produced **64 extra rows**. Each of those replies covered four files. Retrying an entire batch safely requires a stable key and a matching payload for every member.

### What happens when the next file arrives too late to join a batch?

Spread the same offered rate evenly. Dana scheduled a file every 36.36 ms, 128 files per run, and repeated each candidate twice with lost replies. The measured rates were 27.45 files/s for eight single-file requests and 27.52 for four parallel batches. At every release, the previous file had already been dispatched. How often could a 10 ms timer collect a second file?

Across 256 inputs per policy, **every initial POST carried one file**. The batching timer raised the median wait to dispatch from 0.26 to 11.24 ms without saving a single POST. First-save p99 was between 69 and 143 ms for individual requests and between 67 and 143 ms for batching. The sender checked the replies at p99 in 203 and 211 ms respectively. Each policy confirmed all 256 inputs after 32 retries, with one correct row per input. The individual runs are in `results/temperature-transport/confirmation/summary.json`.

**For Lena’s sender, ship one event ID per POST, reuse connections and allow up to eight requests in flight.** On the burst trace this put first-save p99 between 82 and 154 ms, so the new serial control took at least 13.8 times as long even at the least favorable ends of the clock intervals. The four fastest policies had overlapping save intervals. Individual requests had the shortest measured confirmation p99 on the burst trace and recovered a lost reply by replaying just one file. They also handled evenly spaced arrivals without a collection timer or a batch API.

If a burst-only receiver needs fewer POSTs, use keyed batches of up to four. Four slots used 49 POSTs including retries, against 144 for individual requests. Budget for up to 16 event payloads in flight, compared with eight for single-file requests. The slot cap covers active requests. In deployment, keep excess pending files in the durable outbox and bound the in-memory queue separately. For a 100 ms durable-save deadline, even the lowest upper bound was 125 ms on the burst trace. Lena can release the keyed parallel sender and keep a 100 ms promise out of its service objective.

### Which failure would stop the rollout?

On a canary, one incorrect partner name, one invalid submission that changes state or one missing expected failure row is sufficient to stop promotion. That threshold comes from the operation’s definition. The original tests still fail on those deliberately broken candidates. For performance, the team needs a separately agreed budget, a known workload, enough fresh samples and the named receiver. Copying a target from another process or turning off tiering globally supplies none of that evidence. [Part 3 shows why a diagnostic runtime switch needs its own production case](https://devinside.cloud/how-dotnet-runs-03-tiered-compilation-osr-pgo/).

To inspect the stored results, run `python3 tools/part11_matrix.py report --result results/linux/part11/linux-x64/net11.0/mixed` in the download. Each digest belongs to an entire publish folder. To make a new observation on your receiver, start with `./run.sh 11` or `.\run.ps1 11` for the short CLI exercise, then use `tools/part11_matrix.py rehearse` for the full native-receiver matrix. A saved report you inspect is still the original run. [What a performance diagnostic should deliver](https://devinside.cloud/what-a-performance-diagnostic-should-deliver/).

Return to your four opening choices. If you picked the smaller CLI, would you still ship it to the partner who archives exact bytes? If you picked a different worker to save CPU, which fraction of each export could that change touch? Write one condition that would make you switch, along with the observation that could settle it. [A measurement contract for .NET](https://devinside.cloud/same-service-different-numbers-a-measurement-contract-for-net/).

- State the exact user operation and what the consumer must read.
- Name each runtime-dependent feature exercised by that operation.
- Identify the publisher, full transferred files and actual receiver.
- Define the user’s wait, cache policy and sample distribution.
- Count correct sustained work and the resources it consumed.
- Attach one memory observation with its process, boundary and limit.
- List unsupported shapes, untested receivers and the servicing owner.
- Keep a tested alternative and agree on the first observation that reverses the decision.

## Further reading

- [Microsoft .NET support policy and patch requirements](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core?ref=devinside.cloud)
- [Official .NET release metadata](https://builds.dotnet.microsoft.com/dotnet/release-metadata/releases-index.json?ref=devinside.cloud)
- [ASP.NET Core’s Native AOT compatibility table](https://github.com/dotnet/AspNetCore.Docs/blob/main/aspnetcore/fundamentals/native-aot.md?ref=devinside.cloud)
- [ReadyToRun deployment](https://learn.microsoft.com/en-us/dotnet/core/deploying/ready-to-run?ref=devinside.cloud)
- [Diagnostics in Native AOT applications](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/diagnostics?ref=devinside.cloud)
- [.NET 11 minimum hardware requirements](https://learn.microsoft.com/en-us/dotnet/core/compatibility/jit/11/minimum-hardware-requirements?ref=devinside.cloud)

For Intake’s current partner, Dana selects the native CLI with the explicit XML writer. She keeps the ordinary API with its generated error description, the ordinary worker with its explicit XML writer, and ordinary MVC. A change to one partner’s format, one host’s CPU or one page’s latency budget reopens the affected choice.

Take the blank memo in the download and choose one workload of your own. Start by running the real customer operation on the exact published files. Write down what the receiver returned, then the condition under which you would choose a different artifact. The video course’s final task gives you a guided transfer to a different workload. Which observation is still missing from the memo you would sign today?

[How .NET Runs Your Code](https://devinside.cloud/how-dotnet-runs/), part 11 of 11\. Previous, [Memory, Working Set and Heap Retention](https://devinside.cloud/how-dotnet-runs-10-memory-working-set-heap-retention/).