Skip to main content
AkamaiAcquisition announced

A former employee mentioned in a comment that Fermyon, a cloud platform company focused on solving cold start issues with WebAssembly, was acquired by Akamai.

What happened

Post: "How are you guys dealing with .NET cold start in ephemeral containers?"

Source

RedditSep 18, 2026By u/mistertom2u

r/dotnet

How are you guys dealing with .NET cold start in ephemeral containers?

upvotes
35
comments
47

Post

I am curious what people are seeing in production with .NET cold start, especially for workloads where containers are expected to come up quickly and may not live very long. I am less interested in synthetic hello-world numbers and more interested in actual services with DI, configuration, logging, authentication, Minimal APIs or MVC, JSON serialization, database clients, telemetry, etc. For those running regular CoreCLR, what combination of things got startup into an acceptable range? For example: ReadyToRun Composite ReadyToRun Tiered compilation / Quick JIT settings Startup warmup Preloading specific code paths ProfileOptimization / multicore JIT Reducing reflection or moving work to source generators Kubernetes startup/readiness probe tuning Keeping minimum replicas around Anything else that made a measurable difference What kind of cold-start numbers did you start with, and what did you get them down to? I am also especially interested in people who actually deployed NativeAOT for a nontrivial service. NativeAOT obviously attacks cold start much more directly, but once you leave small Minimal API examples there are some real tradeoffs. MVC is out, dynamic/reflection-heavy libraries can become a problem, some libraries need changes for trimming/AOT, and the diagnostics/observability story is different from normal CoreCLR. If you are using NativeAOT in...

Keep reading with a free account

The rest of this post, and every signal for Akamai, is in your free account.

Extracted from these lines

  • [comment u/pfluggs11] Fermyon, a company I worked at previously, built a whole cloud platform to solve this problem. Eventually they were acquired by Akamai but Spin Framework is open source and Spinkube is a CNCF project.

Comments on the post

5 of 47 comments
  • “By not having ephemeral .NET applications for the most part. It's slightly annoying for running an application as a CLI tool, but that's a minor use case for me and we can live with the delay. Running on something like AWS Lambda is probably the biggest use case where this matters. But personally I'd just not run stuff there that cares about cold start performance much, if I can help it. And i”

    u/Tavi2k33 points · Sep 18, 2026View

  • “I will also share my experience. I work for a large software company that makes HCM SaaS product. The cold start performance of .net for AWS lambdas became such a significant issue that we are writing lambdas in Python. We were told that because NativeAOT lacks full observability functionality, and because DataDog, which uses IL weaving, still doesn't support AOT, that using AOT is a "non-starte”

    u/mistertom2u9 points · Sep 18, 2026View

  • “If only we could have AOT compilation without throwing the JIT away. NGEN used to be a thing to speed up larger applications and improve the user experience. NativeAOT feels much like the early versions of .NET Core: throw away most of the existing APIs to make something lean and mean, but lose a lot of functionality in the process. Hopefully we’ll come to our senses and have something in the”

    u/DaveVdE6 points · Sep 18, 2026View

  • “If it’s on the critical path we use Go. .NET is 99% of all code at my workplace, but we do have Go in the 1% where cold starts are not acceptable. AoT may also be a good option, though.”

    u/faculty_for_failure4 points · Sep 18, 2026View

  • “You’re trying to fit round peg into square hole Dotnet just isn’t the right tool for lambda jobs that need to be fast”

    u/aj04134 points · Sep 18, 2026View

Extracted by Autobound

From the Signal API record
Signal
Acquisition announced

What this signalsUser posts often show product pain before it reaches reviews or churn.

Subreddit
r/dotnet
Stage
Confirmed

The full record

From the Signal API record

Numbers

Mentions
1

Details

Timing
Completed
Category
Target
Virality
High
Post kind
Multi media
Prominence
Aside
Company's role
Subject
Signal category
Event

Topics and mentions

Topics

  • acquisition
  • cloud platform
  • webassembly
  • cold start

Products named

  • Spin Framework
  • Spinkube

Extraction

Sentiment
Neutral
Detected
Sep 18, 2026
signal_type
reddit-company
signal_subtype
acquisitionAnnounced

Use this data

Get every Reddit signal for Akamai and the companies you sell to, in the tools you already use.

  1. Ask Claude about it

    Connect Autobound to Claude, Claude Code or Cursor with MCP. Then ask: “What changed at Akamai this week?”

  2. Send it to your own tools

    The Signal API returns Reddit signals for any list of companies as JSON, for your CRM, warehouse or app.

  3. Try it free

    Sign up and spend your free credits on the companies you sell to.

    Start Free1,000 free credits

The API returns more than this page shows

This page shows a preview. The full reddit-company record in the Signal API and MCP can also have these 8 fields. Some fields are empty for some signals.

Company

  • linkedin_urlValue in the API
  • industriesValue in the API
  • employee_count_lowValue in the API
  • employee_count_highValue in the API
  • revenueValue in the API
  • descriptionValue in the API

Signal

  • signal_nameValue in the API
  • associationValue in the API
Show the full JSONThe record on this page and the API request

GET /v1/signals/673b5130-199c-5b26-a0fa-8a50edecdab8 returns this record as JSON. POST /v1/companies/enrich returns every signal for akamai.com.

{
  "signal_id": "673b5130-199c-5b26-a0fa-8a50edecdab8",
  "signal_type": "reddit-company",
  "signal_subtype": "acquisitionAnnounced",
  "detected_at": "2026-09-18T11:50:27+00:00",
  "company": {
    "name": "Akamai",
    "domain": "akamai.com"
  },
  "data": {
    "nsfw": false,
    "stage": "confirmed",
    "awards": 0,
    "timing": "completed",
    "topics": [
      "acquisition",
      "cloud platform",
      "webassembly",
      "cold start"
    ],
    "post_id": "1wjo1em",
    "summary": "A former employee mentioned in a comment that Fermyon, a cloud platform company focused on solving cold start issues with WebAssembly, was acquired by Akamai.",
    "category": "target",
    "comments": [
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/pakfpzt/",
        "depth": 0,
        "score": 33,
        "author": "Tavi2k",
        "excerpt": "By not having ephemeral .NET applications for the most part.\n\n It's slightly annoying for running an application as a CLI tool, but that's a minor use case for me and we can live with the delay.\n\n Running on something like AWS Lambda is probably the biggest use case where this matters. But personally I'd just not run stuff there that cares about cold start performance much, if I can help it. And i",
        "posted_at": "2026-09-18T13:18:31.000Z",
        "author_url": "https://www.reddit.com/user/Tavi2k/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/paka551/",
        "depth": 0,
        "score": 9,
        "author": "mistertom2u",
        "excerpt": "I will also share my experience. I work for a large software company that makes HCM SaaS product. The cold start performance of .net for AWS lambdas became such a significant issue that we are writing lambdas in Python.\n\n We were told that because NativeAOT lacks full observability functionality, and because DataDog, which uses IL weaving, still doesn't support AOT, that using AOT is a \"non-starte",
        "posted_at": "2026-09-18T12:50:47.000Z",
        "author_url": "https://www.reddit.com/user/mistertom2u/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/pak4xqt/",
        "depth": 0,
        "score": 6,
        "author": "DaveVdE",
        "excerpt": "If only we could have AOT compilation without throwing the JIT away. NGEN used to be a thing to speed up larger applications and improve the user experience.\n\n NativeAOT feels much like the early versions of .NET Core: throw away most of the existing APIs to make something lean and mean, but lose a lot of functionality in the process.\n\n Hopefully we’ll come to our senses and have something in the",
        "posted_at": "2026-09-18T12:23:27.000Z",
        "author_url": "https://www.reddit.com/user/DaveVdE/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/pakvv27/",
        "depth": 0,
        "score": 4,
        "author": "faculty_for_failure",
        "excerpt": "If it’s on the critical path we use Go. .NET is 99% of all code at my workplace, but we do have Go in the 1% where cold starts are not acceptable. AoT may also be a good option, though.",
        "posted_at": "2026-09-18T14:32:50.000Z",
        "author_url": "https://www.reddit.com/user/faculty_for_failure/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/pakrdz4/",
        "depth": 0,
        "score": 4,
        "author": "aj0413",
        "excerpt": "You’re trying to fit round peg into square hole\n\n Dotnet just isn’t the right tool for lambda jobs that need to be fast",
        "posted_at": "2026-09-18T14:12:48.000Z",
        "author_url": "https://www.reddit.com/user/aj0413/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/pamvuiv/",
        "depth": 0,
        "score": 2,
        "author": "soundman32",
        "excerpt": "Ive had a C# AOT lambda cold start, read a db, and post a message on a sms in about 20ms.  Obviously its not EF or DI but for a quick lambda you wouldnt do that, would you.",
        "posted_at": "2026-09-18T19:42:44.000Z",
        "author_url": "https://www.reddit.com/user/soundman32/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/paq1u23/",
        "depth": 0,
        "score": 2,
        "author": "zionsati",
        "excerpt": "I'm actually working on an alternate .net compiler that is fully AOT only targeting wasm which means it can be compiled straight to exe.\n\n Early days though, not going to be able to handle aspnetcore unless Microsoft writes a source generated version of it.\n\n The compiler and alt corelib intentionally does not do reflection. Also missing multithreading support at the moment but that is on the road",
        "posted_at": "2026-09-19T06:58:29.000Z",
        "author_url": "https://www.reddit.com/user/zionsati/"
      },
      {
        "url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/comment/palurxu/",
        "depth": 0,
        "score": 2,
        "author": "FragmentedHeap",
        "excerpt": "Rule 1, nothing in hot path that can be avoided. I.e dont wire in app configuration or keybault or other webservices that have to be hit in app start.\n\n .net applications that run in containers that need to start fast have to be optimized to do so not just from how they're configured or how they're compiled but how they're built.\n\n For example if you really need app configuration from azure, you d",
        "posted_at": "2026-09-18T17:02:15.000Z",
        "author_url": "https://www.reddit.com/user/FragmentedHeap/"
      }
    ],
    "evidence": [
      "[comment u/pfluggs11] Fermyon, a company I worked at previously, built a whole cloud platform to solve this problem. Eventually they were acquired by Akamai but Spin Framework is open source and Spinkube is a CNCF project."
    ],
    "virality": "high",
    "post_date": "2026-09-18T11:50:27.000Z",
    "post_kind": "multi_media",
    "post_text": "I am curious what people are seeing in production with .NET cold start, especially for workloads where containers are expected to come up quickly and may not live very long.\n\nI am less interested in synthetic hello-world numbers and more interested in actual services with DI, configuration, logging, authentication, Minimal APIs or MVC, JSON serialization, database clients, telemetry, etc.\n\nFor those running regular CoreCLR, what combination of things got startup into an acceptable range?\n\nFor example:\n\nReadyToRun\n\nComposite ReadyToRun\n\nTiered compilation / Quick JIT settings\n\nStartup warmup\n\nPreloading specific code paths\n\nProfileOptimization / multicore JIT\n\nReducing reflection or moving work to source generators\n\nKubernetes startup/readiness probe tuning\n\nKeeping minimum replicas around\n\nAnything else that made a measurable difference\n\nWhat kind of cold-start numbers did you start with, and what did you get them down to?\n\nI am also especially interested in people who actually deployed NativeAOT for a nontrivial service.\n\nNativeAOT obviously attacks cold start much more directly, but once you leave small Minimal API examples there are some real tradeoffs. MVC is out, dynamic/reflection-heavy libraries can become a problem, some libraries need changes for trimming/AOT, and the diagnostics/observability story is different from normal CoreCLR.\n\nIf you are using NativeAOT in...",
    "sentiment": "neutral",
    "subreddit": "dotnet",
    "post_title": "How are you guys dealing with .NET cold start in ephemeral containers?",
    "prominence": "aside",
    "source_url": "https://www.reddit.com/r/dotnet/comments/1wjo1em/how_are_you_guys_dealing_with_net_cold_start_in/",
    "entity_role": "subject",
    "post_author": "mistertom2u",
    "upvote_ratio": 0.8723404255319149,
    "mention_count": 1,
    "mention_surge": false,
    "subreddit_url": "https://www.reddit.com/r/dotnet/",
    "total_upvotes": 35,
    "comments_total": 47,
    "total_comments": 47,
    "other_companies": [
      {
        "name": "Akamai",
        "role": "acquirer",
        "domain": "akamai.com"
      }
    ],
    "post_author_url": "https://www.reddit.com/user/mistertom2u/",
    "signal_category": "event",
    "comments_included": 12,
    "products_mentioned": [
      "Spin Framework",
      "Spinkube"
    ]
  }
}

Long text fields are shortened on this page.

Looking up one signal by its id is free. Enrich costs 2 credits per signal returned; a call with no results is free.