Fly.io blog digest

The Fly.io blog, one entry per post, with the single fact worth repeating, quoted word for word, and a “use it when” line for field conversations. This file is part 1: the 51 newest posts, 2023-12-18 to 2026-10-23. Pull a proof point, then send the customer the original post.

This page is drawn from https://fly.io/blog/ and each post linked below. Every post listed here was read in the local corpus on 2026-11-04; the corpus copy of each post is the text that was quoted. The blog archive runs back to 2020, and the older posts are digested in the later parts of this page.

How to use this page

• Quote the post, link the post. Blog posts are Fly.io’s own words, written by named engineers. When a number matters, send the link so the customer reads it in context (https://fly.io/blog/).
• Posts age. A post shows how a product worked on its date. Where a post and the docs disagree, the docs describe today’s product (https://fly.io/docs/machines/overview/). Prices in particular: the L40S price below is from August 2024 and is history, not a current quote (https://fly.io/blog/cutting-prices-for-l40s-gpus-in-half/).
• Opinion is opinion. Several posts are essays by Thomas Ptacek, Kurt Mackey or Daniel Botha. Quote them as the author’s view, not as a product commitment (for example https://fly.io/blog/youre-all-nuts/).
• Beta posts are not GA. The Fly Kubernetes post of 2024-03-07 is about a closed beta (https://fly.io/blog/fks-beta-live/). Check the docs before promising a feature.
• Say: “Here is what the engineers wrote, with the date.” Ask: “Which part of this matches the workload you are running?”

Start here: five posts to know

1. The Design & Implementation of Sprites (2026-01-14, Thomas Ptacek). Takeaway: Sprites are Linux VMs with a 100GB durable root filesystem that put themselves to sleep when inactive, built on three decisions that differ from Fly Machines: no container images, object storage for disks, and orchestration from inside the VM (https://fly.io/blog/design-and-implementation/). Use it when: a customer asks how a Sprite differs from a Fly Machine.
2. Code And Let Live (2026-01-09, Kurt Mackey). Takeaway: the Sprites pitch in one walk-through: create in about a second, checkpoint, sleep, come back days later, restore in about a second (https://fly.io/blog/code-and-let-live/). Use it when: you need a five-minute demo script or a quote on why ephemeral sandboxes fall short.
3. Our Best Customers Are Now Robots (2025-04-08, Kurt Mackey). Takeaway: the company’s own account of why agent and vibe-coding platforms fit Fly Machines: fast start, stop-and-resume, and incremental build-up (https://fly.io/blog/fuckin-robots/). Use it when: the buyer builds a coding-agent or app-generation product.
4. Corrosion (2025-10-22, Thomas Ptacek and Peter Cai). Takeaway: how Fly.io keeps its global routing state in sync, including the September 2024 outage it caused, told candidly (https://fly.io/blog/corrosion/). Use it when: a customer asks how Fly Proxy knows where Machines are, or asks for an honest reliability story.
5. Making Machines Move (2024-07-30, Thomas Ptacek). Takeaway: why a Machine with a volume is anchored to one worker, and how “clone” migration lets Fly.io drain workers anyway (https://fly.io/blog/machine-migrations/). Use it when: a customer asks what happens to a Machine with a volume when its host needs maintenance.

Full list, newest first (2023-12 to 2026-10)

2026-10-23: Feng Shui for Robots: The Fly MCP Server

• Fact: “In October 2023, AI agents created 0.1% of the databases on Neon. By October 2025 they created 80% of them.” (https://fly.io/blog/feng-shui-for-robots/). The post introduces mcp.fly.io, one MCP server for Sprites and Fly.io apps.
• Use it when: an agent builder asks how to take a Sprite prototype to production; the post says the usual trigger for moving is needing it always on, and the target is Fly Machines.

2026-10-22: SBD: We Have a Filesystem at Home

• Fact: “Each one was made durable separately, so each one could be right while the others were wrong.” (https://fly.io/blog/sprites-block-device/). It explains why the JuiceFS-based Sprite disk was replaced by the Sprites Block Device, SBD.
• Use it when: a customer asks about Sprite storage reliability or what changed since launch.

2026-09-03: Your Agent Speaks MCP. Give It a Computer.

• Fact: “every Sprite carries machine-readable docs at /.sprite/llm.txt that teach an agent working inside it how the place operates.” (https://fly.io/blog/sprites-mcp/). The post also points agents at sprites.dev/mcp.
• Use it when: someone asks how a coding agent learns to use a Sprite without a human.

2026-07-24: Turn And Face The Strange

• Fact: the post says Fly.io raised more money, is “tagging in Scott Johnston as CEO”, and is focusing the company on Sprites (https://fly.io/blog/kurt-scott-money-sprites/).
• Use it when: a buyer asks about company direction and stability. Send the post itself; it is the company’s own explanation.

2026-06-08: Building Agents that Don’t Break Themselves

• Fact: “The sandbox does real authenticated work and never holds the credential.” (https://fly.io/blog/building-agents-that-dont-break-themselves/). It describes one Sprite per session and a user token injected for a single command.
• Use it when: a multi-user agent product needs isolation per user without leaving secrets on disk.

2026-01-29: Litestream Writable VFS

• Fact: “Sprites launch in under a second, and every one of them boots up with 100GB of durable storage.” (https://fly.io/blog/litestream-writable-vfs/).
• Use it when: a SQLite user asks what Litestream does inside Sprites, or a Sprites buyer asks how storage starts fast.

2026-01-14: The Design & Implementation of Sprites

• Fact: “Creating a Fly Machine can take over a minute.” (https://fly.io/blog/design-and-implementation/). That is the stated reason Sprites drop container images.
• Use it when: a customer asks why Sprites exist next to Fly Machines. See the Start here list above.

2026-01-09: Code And Let Live

• Fact: “ephemeral sandboxes are obsolete” (https://fly.io/blog/code-and-let-live/), the post’s headline claim, backed by checkpoint and restore on a persistent Sprite.
• Use it when: a buyer compares Sprites with throwaway code sandboxes. Attribute the claim to Kurt Mackey.

2025-12-11: Litestream VFS

• Fact: “It runs SQLite hot off an object storage URL.” (https://fly.io/blog/litestream-vfs/). It also shows point-in-time queries with a litestream_time pragma.
• Use it when: a customer wants to query a backup without restoring it.

2025-11-06: You Should Write An Agent

• Fact: the author calls the model API “an HTTP API with, like, one important endpoint” and builds a working agent in a few lines of Python (https://fly.io/blog/everyone-write-an-agent/).
• Use it when: a developer is new to agents and you want a friendly, non-product starting point.

2025-10-22: Corrosion

• Fact: “Within a few seconds every proxy in our fleet had locked up hard.” (https://fly.io/blog/corrosion/). The post dates that outage to September 1, 2024 and calls it the worst the company had experienced.
• Use it when: a customer asks about past incidents. Say: “They wrote up the root cause themselves.” Do not retell it from memory; link it.

2025-10-08: Kurt Got Got

• Fact: “Nothing was at risk other than our Twitter account” (https://fly.io/blog/kurt-got-got/). The post describes a phished company X account and argues for phishing-resistant authentication such as FIDO2 and passkeys.
• Use it when: a security reviewer asks how the vendor handles its own incidents. Note the scope the post claims: the social account only.

2025-10-02: Litestream v0.5.0 is Here

• Fact: “Litestream is faster and now supports efficient point-in-time recovery (PITR).” (https://fly.io/blog/litestream-v050-is-here/). It introduces the LTX file format.
• Use it when: a SQLite customer asks about recovery options for an app on Fly.io.

2025-08-25: Build Better Agents With MorphLLM

• Fact: the post cites MorphLLM’s own benchmark of “98% accuracy in ~6 seconds per file” for code edits (https://fly.io/blog/build-better-agents-with-morphllm/). It is a partner’s number, not a Fly.io measurement.
• Use it when: an agent builder complains that whole-file rewrites are slow and costly.

2025-08-18: Calibrated Trust: Trust Calibration for AI Software Builders

• Fact: “Designing for calibrated trust is the goal, not more trust at any cost.” (https://fly.io/blog/trust-calibration-for-ai-software-builders/).
• Use it when: a product team asks how to design confirmations for an AI feature. Product advice, not a Fly.io feature.

2025-08-11: Games as Model Eval: 1-Click Deploy AI Town on Fly.io

• Fact: the author forked AI Town “to make it absurdly easy to spin up your own AI Town on Fly Machines”, with scale to zero (https://fly.io/blog/games-as-model-eval/).
• Use it when: someone wants a fun, deployable demo of agents on Machines.

2025-08-08: The Future Isn’t Model Agnostic

• Fact: “In a world of model parity, the differentiation moves entirely to the product layer.” (https://fly.io/blog/the-future-isn-t-model-agnostic/).
• Use it when: an AI team is over-investing in model swapping. An opinion post by Daniel Botha.

2025-06-20: Phoenix.new - The Remote AI Runtime for Phoenix

• Fact: Phoenix.new “gives both you and your agent a root shell, in an ephemeral virtual machine (a Fly Machine)” (https://fly.io/blog/phoenix-new-the-remote-ai-runtime/).
• Use it when: an Elixir shop asks what Fly.io itself built on Machines for agents.

2025-06-12: What are MCP Servers?

• Fact: “MCP is an open protocol that standardizes how applications provide context to LLMs.” (https://fly.io/blog/mcps-everywhere/). The post then offers several analogies for it.
• Use it when: a customer needs MCP explained before the Fly.io tooling makes sense.

2025-06-02: My AI Skeptic Friends Are All Nuts

• Fact: “You could write an effective coding agent in a weekend.” (https://fly.io/blog/youre-all-nuts/).
• Use it when: a skeptical engineer wants a peer’s argument. A personal essay by Thomas Ptacek, scoped by the author to software development only.

2025-05-29: Using Kamal 2.0 in Production

• Fact: “Kamal is just one piece of the puzzle.” (https://fly.io/blog/kamal-in-production/). The post is a checklist for deploying a real Rails project with Kamal.
• Use it when: a Rails team is weighing Kamal on their own servers against a platform. It is written by Sam Ruby and is not a comparison with Fly.io.

2025-05-28: parking_lot: ffffffffffffffff…

• Fact: after finding a lock bug in the Rust parking_lot library, the team says “we audited all our catalog locking, got rid of all the iflets, and stopped relying on RAII lock guards.” (https://fly.io/blog/parking-lot-ffffffffffffffff/).
• Use it when: a customer asks how fly-proxy engineering handles hard bugs. Pairs with the Corrosion post.

2025-05-20: Litestream Revamped: SQLite Replication

• Fact: “A generation represents a snapshot and a stream of WAL updates, uniquely identified.” (https://fly.io/blog/litestream-revamped/). The post describes the move to LTX and faster point-in-time restores.
• Use it when: a customer asks how Litestream restores work and why the format changed.

2025-05-19: Launching MCP Servers on Fly.io

• Fact: “The Model Context Protocol is days away from turning six months old.” (https://fly.io/blog/mcp-launch/). It proposes fly mcp launch to run a local-style MCP server remotely.
• Use it when: you need the dated origin of fly mcp; check the docs for the current command shape.

2025-05-07: Provisioning Machines using MCPs

• Fact: “On Monday, I created my first fly volume using an MCP.” (https://fly.io/blog/mcp-provisioning/). Because it wraps flyctl, the author notes destroying a mounted volume would return an error.
• Use it when: a customer fears an LLM deleting live resources.

2025-04-10: 30 Minutes With MCP and flyctl

• Fact: “this whole thing is like 90 lines of code” (https://fly.io/blog/30-minute-mcp/). It exposes only fly logs and fly status.
• Use it when: you want proof that flyctl’s JSON output makes it easy to drive from an agent.

2025-04-08: Our Best Customers Are Now Robots

• Fact: “Start is lightning fast; substantially faster than booting up even a non-virtualized K8s Pod.” (https://fly.io/blog/fuckin-robots/).
• Use it when: a vibe-coding or agent platform asks why Machines fit bursty sessions. See Start here.

2025-03-27: Operationalizing Macaroons

• Fact: “Macaroon tokens are bearer tokens (like JWTs) that use a cute chained-HMAC construction that allows an end-user to take any existing token they have and scope it down, all on their own.” (https://fly.io/blog/operationalizing-macaroons/).
• Use it when: a security team asks how Fly.io API tokens can be narrowed. For current token commands use the docs, not this post.

2025-02-26: Taming A Voracious Rust Proxy

• Fact: “Spurious wakeups should be easy to spot, and triggering a metric when they happen should be cheap” (https://fly.io/blog/taming-rust-proxy/). It traces edge fly-proxy CPU spikes to a TLS stream state-machine bug.
• Use it when: an engineer wants to see how the edge proxy is debugged.

2025-02-14: We Were Wrong About GPUs

• Fact: “GPUs terrified our security team.” (https://fly.io/blog/wrong-about-gpu/). The post says Fly GPU Machines are not going away but a bigger v2 should not be expected.
• Use it when: a customer asks about GPU roadmap. Say: “Their own post says not to wait for a v2.” Confirm current GPU availability in the docs before selling.

2025-02-12: JP Phillips leaves: an exit Q&A post

• Fact: “the P90 for Fly Machine create calls is sub-5-seconds for pretty much every region except for Johannesburg and Hong Kong.” (https://fly.io/blog/the-exit-interview-jp/). This is the engineer’s own statement as of the post date.
• Use it when: you need a sourced figure for Machine create time. Treat it as dated and engineer-reported.

2025-02-10: Did Semgrep Just Get A Lot More Interesting?

• Fact: “Cursor kept trying to get Huntley to use Bazel as a build system.” (https://fly.io/blog/semgrep-but-for-real-now/), the setup for letting an LLM write Semgrep rules.
• Use it when: a security engineer asks about LLM-generated static analysis rules. A short opinion post.

2025-02-10: A Blog, If You Can Keep It

• Fact: the post describes its own recipe: “Write an EffortPost, which is to say a dense technical piece over 2000 words long” (https://fly.io/blog/a-blog-if-kept/).
• Use it when: a DevRel peer asks why the blog reads the way it does.

2025-02-07: VSCode’s SSH Agent Is Bananas

• Fact: VS Code remote editing “runs a Bash snippet stager that downloads an agent, including a binary installation of Node.” (https://fly.io/blog/vscode-ssh-wtf/).
• Use it when: a security-minded customer asks why Fly.io wants agent loops on a clean, disposable Linux instance.

2024-09-24: AI GPU Clusters, From Your Laptop, With Livebook

• Fact: “Any Livebook, including the one running on your laptop, can start a runtime running on a Fly Machine” (https://fly.io/blog/ai-gpu-clusters-from-your-laptop-livebook/).
• Use it when: an Elixir data or ML team asks about Livebook, FLAME and remote GPUs.

2024-08-21: Accident Forgiveness

• Fact: for customers with a support contract at any level, the post says the next unexpected charge will be met with “refund that charge, (almost) no questions asked.” (https://fly.io/blog/accident-forgiveness/).
• Use it when: a buyer fears runaway bills. Say: “The post describes this as a support practice from August 2024.” Confirm current terms with billing before promising it [verify].

2024-08-15: We’re Cutting L40S Prices In Half

• Fact: “We just lowered the prices on NVIDIA L40s GPUs to $1.25 per hour.” (https://fly.io/blog/cutting-prices-for-l40s-gpus-in-half/). Historical price; check https://fly.io/docs/about/pricing/ for today’s.
• Use it when: explaining that the A10 was the most popular GPU in the catalog, per the same post.

2024-07-30: Making Machines Move

• Fact: “Kill, copy, boot is slow. But kill, clone, boot is fast; it can be made asymptotically as fast as stateless migration.” (https://fly.io/blog/machine-migrations/). The mechanism uses the Linux dm-clone feature.
• Use it when: a customer asks how volumes move between hosts. See Start here.

2024-06-19: AWS without Access Keys

• Fact: the setup is to “add Fly.io as an Identity Provider in AWS IAM, giving us an ID we can plug into any IAM Role.” (https://fly.io/blog/oidc-cloud-roles/).
• Use it when: a security team will not hand over AWS keypairs but wants a Fly app to read S3.

2024-05-09: Picture This: Open Source AI for Image Description

• Fact: the post keeps GPU cost down by “restricting Ollama access to internal requests over Flycast” with Fly Proxy autostop (https://fly.io/blog/llm-image-description/).
• Use it when: a customer wants a private, scale-to-zero model endpoint, or an accessibility use case.

2024-03-12: JIT WireGuard

• Fact: “We went from thousands, or hundreds of thousands, of stale WireGuard peers on a gateway to what rounds to none.” (https://fly.io/blog/jit-wireguard-peers/).
• Use it when: someone asks how flyctl connects to private networks, or why gateways are lighter than before.

2024-03-07: Fly Kubernetes does more now

• Fact: “it is our managed Kubernetes service” (https://fly.io/blog/fks-beta-live/); the post says customers are onboarded to a closed beta by email.
• Use it when: a Kubernetes shop asks. Check the current docs for status before promising availability [verify].

2024-02-15: Globally Distributed Object Storage with Tigris

• Fact: “All of the configuration for the AWS S3 library will be injected into your application for you.” (https://fly.io/blog/tigris-public-beta/). The post says Fly.io partnered rather than building object storage itself.
• Use it when: a customer needs S3-style storage with a Fly.io-integrated bill.

2024-02-12: GPUs on Fly.io are available to everyone!

• Fact: “GPUs are now available to everyone!” (https://fly.io/blog/gpu-ga/). It lists a100-40gb, a100-80gb and l40s, set by vm.size.
• Use it when: dating the GPU launch. Read it with the 2025 GPU post for the later stance.

2024-02-05: Event Driven Machines

• Fact: “Once the code finishes, the Machine is destroyed.” (https://fly.io/blog/event-driven-machines/). The Lambdo reference project turns queue events into short-lived Machines.
• Use it when: a customer wants a serverless-style job pattern on Machines.

2024-02-01: Delegating tasks to Fly Machines

• Fact: the flow is “A request hits an endpoint that does some resource-intensive tasks” and is passed to a larger Machine (https://fly.io/blog/delegate-tasks-to-fly-machines/).
• Use it when: a web app has occasional heavy work, such as image resizing.

2024-01-31: Macaroons Escalated Quickly

• Fact: “each claim restricts further what the token authorizes” (https://fly.io/blog/macaroons-escalated-quickly/), the idea behind attenuating a token with caveats.
• Use it when: a developer wants the token design explained with code.

2024-01-08: How Yoko Li makes towns, tamagoes, and tools for local AI

• Fact: “AI Tamago uses an unmodified version of LLaMA 2 7B” (https://fly.io/blog/how-i-fly-yoko-li/).
• Use it when: you want a customer-style profile of small AI projects. This is a profile, not a product claim.

2024-01-04: Deploy Your Own (Not) Midjourney Bot on Fly GPUs

• Fact: “Fly.io has GPUs now!” (https://fly.io/blog/not-midjourney-bot/). It walks through a Discord image bot built on Fooocus and Stable Diffusion.
• Use it when: a customer wants a hands-on GPU tutorial.

2023-12-21: Fly With Alpine

• Fact: “Alpine Linux has a smaller ecosystem that the alternatives, particularly when compared to Debian.” (https://fly.io/blog/fly-with-alpine/). The author frames the switch as an engineering trade-off to test.
• Use it when: a customer wants smaller images and faster startup and asks whether to change base image.

2023-12-18: Introducing Fly Kubernetes

• Fact: the post says Fly.io is “running over 200,000 applications” (https://fly.io/blog/fks/), the scale behind its argument that a global scheduler did not fit.
• Use it when: dating the original FKS announcement and its reasoning. The post notes an update in March 2024.

Full list continued (2022-06 to 2023-12)

Newest first. Each entry has the date, the post, one fact quoted word for word from the post, and when to use it. Old posts describe the platform as it was then, so check the docs before you promise a customer anything current (https://fly.io/docs/machines/overview/).

2023

• 2023-12-13, Fly.io has GPUs now. Fact: “Ampere A100s with 40gb of RAM for $2.50/hr” (https://fly.io/blog/fly-io-has-gpus-now/). Use it when: a customer asks what GPU Machines used to cost. Other posts in this list carry the banner “Fly GPUs are deprecated and will be unavailable after August 1.” (https://fly.io/blog/what-are-these-gpus-really/), so treat the price as history.
• 2023-12-11, What are these “GPUs” really?. Fact: “Fly GPUs are deprecated and will be unavailable after August 1.” (https://fly.io/blog/what-are-these-gpus-really/). Use it when: someone finds the old GPU posts and asks to buy GPU Machines. Say the post is background reading on what a GPU is, and the offer it describes has ended.
• 2023-12-06, Scaling Large Language Models to zero with Ollama. Fact: “you actually stop the running Machine” (https://fly.io/blog/scaling-llm-ollama/). Use it when: a customer thinks scale to zero means a fresh start on a new host. The post says the stopped Machine stays on the same server, so a capacity problem can block a restart (https://fly.io/blog/scaling-llm-ollama/).
• 2023-12-06, Rethinking Serverless with FLAME. Fact: “With FLAME, you treat your entire application as a lambda, where modular parts can be executed on short-lived infrastructure.” (https://fly.io/blog/rethinking-serverless-with-flame/). Use it when: an Elixir team wants elastic scale without splitting the app into services. The Elixir library has a Fly.io backend and can run on any cloud with an instance API (https://fly.io/blog/rethinking-serverless-with-flame/).
• 2023-12-05, The risks of building apps on ChatGPT. Fact: “Single provider risk: Relying deeply on an external service that plays a critical role in our business is risky.” (https://fly.io/blog/the-risks-of-building-apps-on-chatgpt/). Use it when: a buyer weighs a hosted model API against a self-hosted open source model. It is an argument, not a product spec.
• 2023-11-29, Print on Demand. Fact: “Starting up a machine on demand is handled by the auto_stop_machines setting in your fly.toml.” (https://fly.io/blog/print-on-demand/). Use it when: a customer runs headless Chrome for PDFs and pays for idle memory. The pattern is a Machine that starts for the event and stops after it.
• 2023-11-28, Launching to Victory. Fact: “the CLI will infer what you want based on the source code of your application” (https://fly.io/blog/new-launch/). Use it when: a new user asks what fly launch does. It proposes defaults and sends you to a web page to confirm or change them (https://fly.io/blog/new-launch/).
• 2023-11-17, How I Fly. Fact: “when your applications are idle, you can have them scale down to zero copies” (https://fly.io/blog/how-i-fly/). Use it when: you need a first-person, small-site story from a writer who hosts a blog and its CDN on Fly.io (https://fly.io/blog/how-i-fly/).
• 2023-11-13, Transcribing on Fly GPU Machines. Fact: “the difference worth caring about is 40 vs 80 GB of memory” (https://fly.io/blog/transcribing-on-fly-gpu-machines/). Use it when: you are reading an old Whisper walkthrough. It builds on the same GPU offer that is now deprecated (https://fly.io/blog/transcribing-on-fly-gpu-machines/).
• 2023-09-13, Skip the API, Ship Your Database. Fact: “Corrosion keeps a fast, local copy of all this data in a SQLite database.” (https://fly.io/blog/skip-the-api/). Use it when: a team asks why LiteFS exists. Fly.io used it internally to share Corrosion data between services instead of building an API (https://fly.io/blog/skip-the-api/).
• 2023-09-12, Automated Sentry Error Tracking. Fact: “All new deployments on Fly.io get a Sentry project provisioned automatically.” (https://fly.io/blog/sentry-partnership/). Use it when: someone asks about error tracking. The post lists “50,000 Error events” a month for one year (https://fly.io/blog/sentry-partnership/), so confirm the offer is still live [verify].
• 2023-08-30, Tracking Application-Level Consistency with LiteFS. Fact: “Transaction ID (TXID): An identifier that monotonically increases with every successful write transaction.” (https://fly.io/blog/tracking-consistency-with-litefs/). Use it when: a user reads their own write from a replica and sees old data. The TXID lets the app wait for a replica to catch up.
• 2023-07-21, Multiple Logs for Resiliency. Fact: “Your application writes logs to STDOUT. Fly.io will take that output and send it to NATS.” (https://fly.io/blog/redundant-logs/). Use it when: logs went missing during an outage. The post suggests keeping a second copy of the logs outside the shipping path.
• 2023-07-12, Tokenized Tokens. Fact: “Our Rails API has an access token for Vault that allows it to set secrets, but not read any of them back, like a kind of diode.” (https://fly.io/blog/tokenized-tokens/). Use it when: a security reviewer asks how Fly.io handles secrets. The post also introduces the open source Tokenizer proxy that injects secrets into third-party API calls (https://fly.io/blog/tokenized-tokens/).
• 2023-07-11, Fly.io (heart) Bun. Fact: “Be forewarned that everything is beta at this point.” (https://fly.io/blog/flydotio-heart-bun/). Use it when: a customer asks about Bun on Fly.io. Bun 1.0 had not shipped when this was written, so check current docs.
• 2023-07-05, LiteFS Cloud: Distributed SQLite with Managed Backups. Fact: “Update, October 15, 2024: LiteFS Cloud has been retired.” (https://fly.io/blog/litefs-cloud/). Use it when: a customer wants managed LiteFS backups. The post points to Litestream for SQLite backups, and LiteFS itself is still open source (https://fly.io/blog/litefs-cloud/).
• 2023-06-27, We Raised A Bunch Of Money. Fact: “raised an additional $70MM led by EQT Ventures” (https://fly.io/blog/we-raised-a-bunch-of-money/). Use it when: a buyer asks if the company will last. The same post explains the thinking behind Machines: “So we built Fly Machines, which makes spinning up a VM as straightforward as calling a function.” (https://fly.io/blog/we-raised-a-bunch-of-money/).
• 2023-05-31, Python Async Workers on Fly Machines. Fact: “The web application calls the Fly Machines API to start a new machine” (https://fly.io/blog/python-async-workers-on-fly-machines/). Use it when: a Python app needs background jobs without a worker fleet. The pattern passes job parameters through Redis (https://fly.io/blog/python-async-workers-on-fly-machines/).
• 2023-05-18, Vanilla with Candy Sprinkles. Fact: “Whereas large frameworks make a number of choices for you, being able to selectively include only the tools you need can provide you with a preconfigured configuration to build upon.” (https://fly.io/blog/vanilla-candy-sprinkles/). Use it when: a JavaScript team wants a small stack, not a full framework.
• 2023-05-15, Playing Traffic Cop with Fly-Replay. Fact: “This only works for sending apps within the same Fly.io organization.” (https://fly.io/blog/how-to-fly-replay/). Use it when: a customer wants one router app to send each request to a per-customer app, region or Machine. Replay is a response header read by Fly Proxy (https://fly.io/blog/how-to-fly-replay/).
• 2023-05-11, The JavaScript Ecosystem is Delightfully Weird. Fact: “Bundling JS to run in the browser was the first sign of weirdness.” (https://fly.io/blog/js-ecosystem-delightfully-wierd/). Use it when: you need background on why JavaScript deploys vary so much. It is context, not a how-to.
• 2023-05-08, Deploying LangChain to Fly.io. Fact: “I recently created a minimal application using LangChain and deployed it to Fly.io.” (https://fly.io/blog/deploying-langchain-to-fly-io/). Use it when: a Python user wants a first LLM app on Fly.io. It uses Flask and an OpenAI key, and the model named in it is dated (https://fly.io/blog/deploying-langchain-to-fly-io/).
• 2023-04-24, Fly.io (heart) JS. Fact: “The right place to start is package.json.” (https://fly.io/blog/flydotio-heart-js/). Use it when: a Node customer asks how Fly.io picks a Dockerfile. The dockerfile-node project generates one from package.json conventions.
• 2023-02-22, Gossip Glomers. Fact: “we teamed up with Kyle Kingsbury, author of Jepsen, to develop a series of distributed systems challenges” (https://fly.io/blog/gossip-glomers/). Use it when: a DevRel contact wants a community event idea. It is a coding challenge, not a product.
• 2023-02-21, Shipping Logs. Fact: “Flaps ensures you only see your own logs.” (https://fly.io/blog/shipping-logs/). Use it when: a customer wants logs in Datadog, Loki or similar. The post describes the Fly Log Shipper, which runs Vector with a sink you choose (https://fly.io/blog/shipping-logs/).
• 2023-02-01, Carving The Scheduler Out Of Our Orchestrator. Fact: “Bin packing is wrong for platforms like Fly.io.” (https://fly.io/blog/carving-the-scheduler-out-of-our-orchestrator/). Use it when: an architect asks how Fly.io places workloads. The post describes the first year after launch as a Rust proxy plus a Golang Nomad driver (https://fly.io/blog/carving-the-scheduler-out-of-our-orchestrator/).
• 2023-01-31, Fly.io is in Johannesburg. Fact: “if your users support the Springboks and Banyana Banyana, you should put your whole app in JNB.” (https://fly.io/blog/fly-in-johannesburg/). Use it when: a customer has users in South Africa. Check the current region list before promising capacity (https://fly.io/docs/reference/regions/).
• 2023-01-04, SQLite WAL Mode, and How LiteFS Replicates It. Fact: “To switch a database to WAL mode, run PRAGMA journal_mode=WAL; once.” (https://fly.io/blog/wal-mode-in-litefs/). Use it when: a SQLite user asks about concurrency settings. It explains the difference between the rollback journal and the write-ahead log.

2022

• 2022-12-15, Launching Redis by Upstash. Fact: “Redis by Upstash is managed Redis living right next door to your Fly.io apps.” (https://fly.io/blog/launching-redis-by-upstash/). Use it when: a customer asks who runs their Redis. Upstash does, as a partner. The launch example shows a free 100 MB plan, so check current terms [verify] (https://fly.io/blog/launching-redis-by-upstash/).
• 2022-12-06, Logbook: November 14 to December 5, 2022. Fact: “Build real-time applications on any backend with Replicache and Fly, run Cron on Fly, two LiveWire how-tos, and learn how Fly reluctantly built its Postgres database service.” (https://fly.io/blog/logbook-november-14-to-december-5-2022/). Use it when: you want the index of that month’s guides, including Supercronic for cron.
• 2022-11-29, How We Built Fly Postgres. Fact: “Fly.io is an ambivalent database provider” (https://fly.io/blog/how-we-built-fly-postgres/). Use it when: a customer assumes Fly Postgres is a fully managed service. Read it with the Oct 2022 logbook below, and note it describes Stolon-based clusters (https://fly.io/blog/how-we-built-fly-postgres/).
• 2022-11-23, Real-Time Collaboration with Replicache and Fly-Replay. Fact: “The WebSocket connection is stored in a map on the server with other WebSocket connections for that given spaceID.” (https://fly.io/blog/replicache-machines-demo/). Use it when: a team needs every user of one document routed to the same server. Fly-Replay does the routing.
• 2022-11-14, Logbook: November 7 to November 14, 2022. Fact: “Deploy your own MinIO S3-compatible object storage to Fly” (https://fly.io/blog/logbook-november-7-to-november-14-2022/). Use it when: a customer wants object storage in the same datacenter as the app. The post still suggests a hosted S3 service where that fits.
• 2022-11-08, Logbook: October 29 to November 6, 2022. Fact: “Fly tries to make it very clear that we provide tools that make it easy to provision and manage a Postgres database cluster” (https://fly.io/blog/logbook-october-29-to-november-6-2022/). Use it when: you need a dated example of Fly.io telling users that Postgres here is not managed.
• 2022-11-02, A love letter to React. Fact: “Phoenix borrowed a lot from React when we first shipped LiveView in 2018” (https://fly.io/blog/love-letter-react/). Use it when: an Elixir or Phoenix contact wants the origin story. It is about framework design, not hosting.
• 2022-10-31, Logbook: October 21 to 28, 2022. Fact: “Fly does give you great tools to provision and upgrade Postgres instances” (https://fly.io/blog/logbook-october-21-to-28-2022/). Use it when: you must explain the shared-responsibility line for Postgres. The same entry warns that a full disk without monitoring means customers find out first (https://fly.io/blog/logbook-october-21-to-28-2022/).
• 2022-09-21, Introducing LiteFS. Fact: “any node marked as a candidate can become the primary node by obtaining a time-based lease” (https://fly.io/blog/introducing-litefs/). Use it when: someone asks how LiteFS picks the one writer. The lease comes from Consul, and a static primary is also allowed (https://fly.io/blog/introducing-litefs/).
• 2022-09-14, Scale-to-Zero Minecraft server with Terraform and Fly Machines. Fact: “Fly Machines: Firecracker VMs you can start and stop fast with a REST API.” (https://fly.io/blog/scale-to-zero-minecraft/). Use it when: a customer wants to run a game server only while players are online, or to see the Terraform provider in use.
• 2022-09-07, How the SQLite Virtual Machine Works. Fact: “As of this writing, there are 186 commands, or opcodes, that the SQLite VM can understand.” (https://fly.io/blog/sqlite-virtual-machine/). Use it when: you want depth on how SQLite runs a query. It is teaching content from the LiteFS author.
• 2022-08-24, How SQLite Scales Read Concurrency. Fact: “In 2010, SQLite introduced a second method called the write-ahead log” (https://fly.io/blog/sqlite-internals-wal/). Use it when: someone repeats the claim that SQLite does not scale for reads. The post argues that advice is out of date.
• 2022-08-15, Building an In-Browser IDE the Hard Way. Fact: “Machines can be started and stopped manually using their REST API or flyctl” (https://fly.io/blog/remote-ide-machines/). Use it when: a customer wants a personal dev environment that is off when idle. The post says stopped Machines do not bill for CPU or RAM.
• 2022-08-10, How SQLite helps you do ACID. Fact: “Rollback journals are even resistant to failures during their own recovery.” (https://fly.io/blog/sqlite-internals-rollback-journal/). Use it when: a data-safety question comes up about SQLite on a volume. Pair it with the volume snapshot rules below.
• 2022-08-04, Volume Expansion and Snapshot Restores. Fact: “Volume snapshots are taken daily (but not at the same time every day), and shunted off to object storage where they live for five days before they expire.” (https://fly.io/blog/volumes-expand-restore/). Use it when: a customer asks about volume backups and retention. This is a 2022 value, so confirm current retention in the docs [verify] (https://fly.io/docs/volumes/).
• 2022-07-27, SQLite Internals: Pages & B-trees. Fact: “SQLite groups rows together into 4KB chunks” (https://fly.io/blog/sqlite-internals-btree/). Use it when: you want the page model that LiteFS replication is built on.
• 2022-07-26, Launching Laravel Bytes. Fact: “Laravel is supported in the fly launch command” (https://fly.io/blog/launching-laravel-bytes/). Use it when: a PHP team asks where the Laravel tutorials live. Laravel Bytes was the home for them.
• 2022-07-19, How LiveView Took on a Life of Its Own. Fact: “I wanted to write dynamic server-rendered applications without writing JavaScript.” (https://fly.io/blog/liveview-its-alive/). Use it when: an Elixir buyer wants to know why Phoenix apps keep long-lived connections to the server.
• 2022-07-18, Logbook - 2022-07-18. Fact: “The Pro Plan now includes usage credits equivalent to its price: $99.” (https://fly.io/blog/logbook-2022-07-18/). Use it when: you need dated pricing history. It is not current pricing, so send customers to https://fly.io/docs/about/pricing/.
• 2022-07-07, SOC2: The Screenshots Will Continue Until Security Improves. Fact: “The guts of a SOC2 audit are a giant spreadsheet questionnaire” (https://fly.io/blog/soc2-the-screenshots-will-continue-until-security-improves/). Use it when: a buyer asks about compliance. The post says Fly.io became SOC2 compliant in 2022, so ask the company for the current report [verify].
• 2022-06-30, The Serverless Server. Fact: “Fly Machines are Firecracker VMs with a fast REST API that can boot instances in about 300ms, in any region supported by Fly.io.” (https://fly.io/blog/the-serverless-server/). Use it when: a customer compares Machines with Lambda-style serverless. The same post puts Firecracker itself at “We can be up and running in under 125ms.” (https://fly.io/blog/the-serverless-server/).
• 2022-06-23, Logbook - 2022-06-23. Fact: “We now have a YUL region (Montreal, QC, Canada)” (https://fly.io/blog/logbook-2022-06-23/). Use it when: you need the date a region appeared, or a sample of how many small platform changes ship in a month.

Full list continued (2020-12 to 2022-06)

Each entry has the date, the post, one fact copied verbatim from the post, and a “use it when” line. Many of these posts are 2020 to 2022 history: the platform then ran apps on Nomad and had no Machines API at first, so check the docs before quoting a limit or a price as current.

• 2022-06-15 How to make Rust leak memory (also: how to make it stop). Fact: “Which means every request was leaking a tiny bit of memory.” (https://fly.io/blog/rust-memory-leak/). The leak was in fly-proxy’s own old tracing code, not in Honeycomb (https://fly.io/blog/rust-memory-leak/). Use it when: a customer asks how mature the proxy is, or you want a candid engineering-postmortem example.
• 2022-06-10 Logbook - 2022-06-10. Fact: “This will make deploys 2-5x faster for apps that run in many regions.” (https://fly.io/blog/logbook-2022-06-10/). The same changelog adds the --build-secret flag for fly deploy (https://fly.io/blog/logbook-2022-06-10/). Use it when: a customer with a multi-region app complains about deploy time on an old flyctl.
• 2022-06-01 Logbook - 2022-06-01. Fact: “Added a 512MB swap for release commands, in case they need more memory than normal VM runtime.” (https://fly.io/blog/logbook-2022-06-01/). Use it when: a release command runs out of memory and you need to know whether that was ever a platform decision.
• 2022-05-26 Logbook - 2022-05-26. Fact: “Fly HA Postgres instances will turn read-only, and thus fail a health check, when their volume is 90% full.” (https://fly.io/blog/logbook-2022-05-26/). Use it when: a Postgres app suddenly goes read-only and the volume is nearly full.
• 2022-05-24 Fly Machines: an API for fast-booting VMs. Fact: “Fly Machines are VMs with a fast REST API that can boot instances in about 300ms.” (https://fly.io/blog/fly-machines/). The post’s advice is to create machines ahead of time and start them when needed (https://fly.io/blog/fly-machines/). Use it when: explaining where Machines came from, or the create-then-start pattern for functions-style workloads.
• 2022-05-13 Logbook - 2022-05-13. Fact: “Put in a workaround for an MTU issue causing IPv6 connection errors for people on tunnels, DSL, etc.” (https://fly.io/blog/logbook-2022-05-13/). Use it when: a customer on a tunnel or DSL link sees odd IPv6 connection errors.
• 2022-05-09 I’m All-In on Server-Side SQLite. Fact: Litestream replicates “to S3, or Minio; to Azure, or Backblaze B2, or Digital Ocean or Google Cloud, or an SFTP server.” (https://fly.io/blog/all-in-on-sqlite-litestream/). Use it when: a customer wants SQLite in production and asks how it is backed up.
• 2022-05-05 Logbook - 2022-05-05. Fact: “Changed the default size for new persistent volumes from 10GB to 3GB.” (https://fly.io/blog/logbook-2022-05-05/). Use it when: someone asks why volume defaults are small, or how a 2022 volume size was chosen.
• 2022-04-25 Accessibility and Real-time Apps: Clearing Fog and Picking Fruit. Fact: “the aria-label attribute adds a label that is only visible to assistive technologies.” (https://fly.io/blog/accessibility-clearing-the-fog/). Use it when: a LiveView or Phoenix customer asks for quick accessibility wins on icon-only buttons.
• 2022-04-20 Logbook - 2022-04-20. Fact: “Backup regions (by far our most confusing misfeature) are now disabled by default.” (https://fly.io/blog/logbook-2022-04-20/). Use it when: an old app shows VMs in regions the owner never chose.
• 2022-03-29 A Foolish Consistency: Consul at Fly.io. Fact: “To start with, we have a single Consul namespace, and a single global Consul cluster.” (https://fly.io/blog/a-foolish-consistency/). The post argues that keeping every region on one consistent view is a “mug’s game” in its own words (https://fly.io/blog/a-foolish-consistency/). Use it when: a technical buyer asks how service discovery worked, and why it was reworked.
• 2022-03-03 Accessibility for real-time web apps. Fact: “Accessibility is not a destination, but a process.” (https://fly.io/blog/intro-to-accessibility/). Use it when: you need a short, human framing of accessibility for a product team.
• 2022-02-09 Our User-Mode WireGuard Year. Fact: “Practically everything that talks to anything else at Fly.io does so over WireGuard.” (https://fly.io/blog/our-user-mode-wireguard-year/). The post is a candid look at how flyctl came to run WireGuard in user mode (https://fly.io/blog/our-user-mode-wireguard-year/). Use it when: a customer asks why fly ssh and deploys open a WireGuard tunnel.
• 2022-02-08 Turbocharge your Heroku Apps with New Turboku. Fact: “You can even talk to your Heroku Postgres, no data migration required.” (https://fly.io/blog/new-turboku/). Use it when: a Heroku customer wants a low-risk first deploy before moving data.
• 2022-02-01 LiveBeats: Building a social music app with Phoenix LiveView. Fact: “Meet LiveBeats, a social music application we wrote to show off the LiveView UX, while serving as a learning example and a test-bed for new LiveView features.” (https://fly.io/blog/livebeats/). The “free for small Phoenix projects” line in that post is history, not a current offer. Use it when: an Elixir team wants a reference app.
• 2022-01-20 Free Postgres Databases. Fact: “New accounts get a free trial instead, and today we recommend Managed Postgres for most apps.” (https://fly.io/blog/free-postgres/). The 2022 free allowance is gone, per the update note at the top of the post (https://fly.io/blog/free-postgres/). Use it when: a customer quotes this post as a current free tier. Correct them and link the pricing docs.
• 2022-01-10 Self-service account deactivation: why it’s harder than you would think. Fact: “until recently, to get your account deactivated, you had to email support.” (https://fly.io/blog/self-service-account-deactivation/). Use it when: a customer wants to leave and asks what the self-service path must clear first, such as apps and shared organizations.
• 2021-11-18 Launching Livebook using LiveView. Fact: “The solution was to encrypt the private data we want to keep using Phoenix.Token.encrypt/4.” (https://fly.io/blog/creating-the-livebook-launcher-in-liveview/). The encrypted blob is kept in the browser’s SessionStorage, not on Fly’s servers (https://fly.io/blog/creating-the-livebook-launcher-in-liveview/). Use it when: a LiveView team needs to hold secrets across a reconnect.
• 2021-10-21 How Safari Ruined My Tuesday. Fact: “Safari 15 shipped in September 2021 and included an obscure CSS bug that broke most LiveView applications.” (https://fly.io/blog/how-safari-ruined-my-tuesday/). Use it when: a LiveView app is dead to clicks on Safari after a disconnect.
• 2021-10-18 32 Bit Real Estate. Fact: “That means it costs $23,040 to handle 512 virtual machines with IPv4 addresses.” (https://fly.io/blog/32-bit-real-estate/). This is the post’s own worked example, using its $45 per address assumption (https://fly.io/blog/32-bit-real-estate/). Use it when: a customer asks why a dedicated IPv4 address is a billed item. Current prices are in the docs, not here.
• 2021-09-22 How We Got to LiveView. Fact: “LiveView strips away layers of abstraction, because it solves both the client and server in a single abstraction.” (https://fly.io/blog/how-we-got-to-liveview/). Use it when: someone asks why Fly cares so much about Elixir and Phoenix.
• 2021-09-01 Full-stack developer post. Fact: “Our UX stack today is a combination of Rails, GraphQL, and some Go (our platform stack is Rust and Go).” (https://fly.io/blog/fly-io-is-hiring-full-stack-developers/). It is dated 2021 and describes the team’s stack at the time. Use it when: you need a dated snapshot of the stack, and nothing about current needs.
• 2021-08-24 API Tokens: A Tedious Survey. Fact: “Today, Fly.io API access is all-or-nothing. Everyone has root credentials.” (https://fly.io/blog/api-tokens-a-tedious-survey/). That was 2021, before scoped tokens; the post says the plan was a Macaroon-based scheme (https://fly.io/blog/api-tokens-a-tedious-survey/). Use it when: a security reviewer asks about token design history. Check the docs for today’s token model.
• 2021-07-30 Better Business Intelligence in Elixir with Livebook. Fact: “Livebook can be a better BI tool for Elixir developers.” (https://fly.io/blog/better-business-intelligence-in-elixir-with-livebook/). Use it when: a small team wants ad hoc reports from a running Elixir app.
• 2021-07-27 FYI: Phoenix drops webpack and npm for esbuild. Fact: “npm was involved in 591, webpack played a role in 79, and brunch was a factor for 171.” (https://fly.io/blog/phoenix-moves-to-esbuild-for-assets/). Those counts are out of 2,034 Phoenix issues (https://fly.io/blog/phoenix-moves-to-esbuild-for-assets/). Use it when: a Phoenix customer asks why new apps build without node.
• 2021-07-16 Last Mile Redis. Fact: “Run standalone Redis servers and app servers in each region you care about.” (https://fly.io/blog/last-mile-redis/). Use it when: a customer wants a per-region cache without writing sharding logic.
• 2021-07-01 FYI: Livebook 0.2 with Kino. Fact: “The other big Kino feature is called data_table.” (https://fly.io/blog/livebook-with-kino/). Use it when: you only need a pointer to the Livebook 0.2 release notes. It is a short community note.
• 2021-06-30 Globally Distributed Postgres. Fact: “In 8 lines of code, we catch the read-only exceptions and spit out a fly-replay header” (https://fly.io/blog/globally-distributed-postgres/). The header tells the proxy to retry the request in the writer’s region (https://fly.io/blog/globally-distributed-postgres/). Use it when: a customer wants read replicas near users and writes sent to one region.
• 2021-06-28 Monitoring Elixir Apps on Fly.io With Prometheus and PromEx. Fact: “You can do advanced monitoring with Prometheus on Fly.io without installing anything!” (https://fly.io/blog/monitoring-your-fly-io-apps-with-prometheus/). Use it when: an Elixir team asks how to get dashboards from built-in metrics.
• 2021-06-14 Observing Elixir in Production. Fact: “if your app runs on Fly, you can open a secure, private, direct connection from your dev machine to your production network” (https://fly.io/blog/observing-elixir-in-production/). Use it when: a customer wants to attach a remote tool to a live app over WireGuard.
• 2021-05-26 Livebook is a secret weapon for documentation. Fact: “Notebook files are stored as plain Markdown files” (https://fly.io/blog/livebook-for-app-documentation/). Use it when: a team wants runnable docs that sit in version control.
• 2021-05-20 Hooking Up Fly Metrics. Fact: “All Fly apps now include built-in Prometheus metrics.” (https://fly.io/blog/hooking-up-fly-metrics/). The post walks through a Grafana data source with an Authorization header (https://fly.io/blog/hooking-up-fly-metrics/). Use it when: a customer asks how to chart Fly metrics in their own Grafana.
• 2021-05-13 Fly’s Prometheus Metrics. Fact: “We run Telegraf agents on our nodes to scrape local Prometheus sources, and Vicky scrapes Telegraf.” (https://fly.io/blog/measuring-fly/). Use it when: an observability lead wants to know how Fly’s own metrics pipeline works.
• 2021-04-29 Building a Distributed Turn-Based Game System in Elixir. Fact: “So I set out to see if I could create a fully distributed, clustered, privately networked, global game server system.” (https://fly.io/blog/building-a-distributed-turn-based-game-system-in-elixir/). Use it when: a customer wants a worked example of clustering over private networking.
• 2021-04-08 Docker without Docker. Fact: “An OCI image is just a stack of tarballs.” (https://fly.io/blog/docker-without-docker/). The post shows how an image becomes block devices for Firecracker (https://fly.io/blog/docker-without-docker/). Use it when: a customer asks whether their container runs in Docker. It does not; it becomes a microVM.
• 2021-03-16 The 5-hour CDN. Fact: “CDNs are just web applications.” (https://fly.io/blog/the-5-hour-content-delivery-network/). Use it when: a customer wants to build a caching proxy on Fly instead of buying a CDN.
• 2021-03-01 SSH and User-mode IP WireGuard. Fact: “We wrote a teeny, tiny, trivial SSH server in Go, called Hallpass.” (https://fly.io/blog/ssh-and-user-mode-ip-wireguard/). Use it when: someone asks how fly ssh reaches a VM.
• 2021-02-15 Persistent Storage and Fast Remote Builds. Fact: “Until somewhat recently, micro-VMs on Fly were entirely ephemeral.” (https://fly.io/blog/persistent-storage-and-fast-remote-builds/). Use it when: a customer asks when volumes arrived, or why a volume is not a replicated database.
• 2021-02-12 The Tokio Upgrade from 0.2 to 1.x. Fact: “With Tokio 1.0, the team has decided to forego all Stream implementations until its stabilization in the stdlib.” (https://fly.io/blog/the-tokio-1-x-upgrade/). Use it when: a Rust user hits the same upgrade, or you need proof the proxy is Rust on Tokio and Hyper.
• 2021-02-05 You should know about Server-Side Request Forgery. Fact: “Smokescreen is an egress proxy that was built at Stripe to help manage outgoing connections in a sensible and safe way.” (https://fly.io/blog/practical-smokescreen-sanitizing-your-outbound-web-requests/). Use it when: a security reviewer asks how to limit outbound requests from an app.
• 2021-01-26 The January 2021 Fly ChangeLog. Fact: “Let your apps talk amongst themselves with 6PN networking.” (https://fly.io/blog/the-january-2021-fly-changelog/). The same issue covers IPv6 WireGuard peering and count scaling (https://fly.io/blog/the-january-2021-fly-changelog/). Use it when: you need the month 6PN reached users.
• 2021-01-18 Fly In 2020 - A year in features (and articles). Fact: the year starts with “Fly Global Application Platform launches” in January (https://fly.io/blog/fly-in-2020/). Use it when: you want a month-by-month timeline of 2020.
• 2021-01-14 How to build a global message service with NATS. Fact: “Chat: A 6PN Example with NATS builds on a previous Fly example messaging application using WebSockets to talk to users, and using NATS powered messaging to run in any region.” (https://fly.io/blog/how-to-build-a-global-message-service-with-nats/). Use it when: a customer needs a pub/sub example over private networking.
• 2021-01-14 Building clusters with serf, my new favorite thing. Fact: “Serf runs without leaders (cluster members come and go, and everybody just figures things out) and no storage requirements.” (https://fly.io/blog/building-clusters-with-serf/). Use it when: a customer needs peers to find each other without a database.
• 2021-01-05 Get fly with your Fly command line. Fact: “It started off as flyctl but we kept being asked when would the command become fly.” (https://fly.io/blog/get-fly-with-your-fly-command-line/). Use it when: a customer asks if fly and flyctl differ. In this post they are interchangeable.
• 2020-12-29 Graceful VM exits, some dials. Fact: “Shared CPU VMs allow up to 5 minutes and dedicated CPU VMs allow up to 24 hours. The default is 5 seconds.” (https://fly.io/blog/graceful-vm-exits-some-dials/). That describes kill_timeout in 2020; confirm the current limit in the docs [verify]. Use it when: connections get cut during deploys.
• 2020-12-23 IPv6 WireGuard Peering. Fact: “We start with the IPv6 ULA prefix fdaa::/16” (https://fly.io/blog/ipv6-wireguard-peering/). Use it when: a customer asks what address space private networking uses.
• 2020-12-10 New VMs: more RAM, extra CPU, and a dollar menu. Fact: “Our new VMs come in two flavors, shared-cpu with up to 2GB of RAM for lightweight apps, and dedicated-cpu with up to 64GB of RAM for not-quite-big-data-but-it-should-be-fast.” (https://fly.io/blog/new-vms-more-ram-extra-cpu-and-a-dollar-menu/). The prices in that post are 2020 history. Use it when: you need the origin of the shared and dedicated CPU split.
• 2020-12-08 6PN: Private IPv6 Networking for Fly Apps. Fact: “A 6PN network connects all the applications in a Fly.io organization.” (https://fly.io/blog/incoming-6pn-private-networks/). Use it when: a customer asks whether their own apps can talk privately without mTLS.
• 2020-12-03 We cut bandwidth prices. Go nuts.. Fact: “$0.02 per GB for outbound data transfer from North America and Europe, and $0.04 per GB almost everywhere else.” (https://fly.io/blog/we-cut-bandwidth-prices-go-nuts/). That is the December 2020 price; use the docs for today’s rate. Use it when: a customer cites old bandwidth numbers.

Full list continued (2020-01 to 2020-11)

These 50 posts are the oldest Fly.io blog posts, from the launch year 2020, newest first. They describe the pre-Machines platform: apps were Docker images, scaling was set with flyctl scale and region pools, and the CLI was still moving from flyctl to fly. Treat every command, limit and feature below as historical and likely out of date. For current behavior, use the docs (https://fly.io/docs/machines/overview/). Use these posts for origin stories and for how did Fly.io get here questions, not for instructions.

• 2020-11-30, The November Fly Changelog. Fact: the new example guides lean on “persistent Volumes support for Fly apps, aka writable disk space” (https://fly.io/blog/the-november-fly-changelog/). Historical: volumes were in preview then. Use it when: a customer asks how long Fly.io has had volumes, or where fly secrets import came from.
• 2020-11-27, More Appkata Examples to Try on Fly. Fact: “This uses mkcert to make it as quick and simple as possible to create TLS certificates so you can secure your Redis.” (https://fly.io/blog/more-appkata-examples-to-try-on-fly/). Use it when: someone wants a worked example of a self-hosted Redis with TLS or Node-RED, and you want to show the early example-app habit.
• 2020-11-18, Appkata - Example Apps on Fly. Fact: the Redis example “also shows how to use the Volumes feature of Fly to add persistent storage to your Redis so it can be restarted and recover like nothing had happened.” (https://fly.io/blog/appkata-example-apps-on-fly/). Use it when: a customer asks whether Fly.io can run stateful services like Redis, MinIO or a Git server. Check current volume rules in the docs first.
• 2020-10-30, Fly Answers Questions - Suspend, Resume, Restart and Redis. Fact: “Fly applications stay running all the time ready to service your traffic.” (https://fly.io/blog/fly-answers-questions-suspend-resume-restart-and-redis/). Historical: the post explains fly suspend and fly resume on the old app model. Use it when: you need the 2020 baseline for does Fly stop my app when idle, then confirm today’s behavior in the docs.
• 2020-10-27, The October Fly Changelog: Preview Disks and DNS and Better Builtins. Fact: “These persist between restarts, deployments and even the app being suspended.” (https://fly.io/blog/the-october-fly-changelog-preview-disks-and-dns-and-better-builtins/). Use it when: tracing when persistent disks and env vars in fly.toml first appeared.
• 2020-10-20, BPF, XDP, Packet Filters and UDP. Fact: “you can now, in a beta sort of way, deploy UDP applications on Fly.” (https://fly.io/blog/bpf-xdp-packet-filters-and-udp/). Historical: it was a 2020 beta, so check the docs before promising UDP details. Use it when: a network-minded buyer asks how Fly.io routes non-HTTP traffic. This is the deep technical story (XDP, BPF, WireGuard) behind it.
• 2020-10-15, Fly Behind The Scenes: Fresh Logging. Fact: the old logging setup had to cope with “Between 20,000 and 30,000 logs per second.” (https://fly.io/blog/fly-behind-the-scenes-fresh-logging/). Historical: the platform was rebuilt in 2020. Use it when: someone asks about log scale or how flyctl logs is fed. Treat the design as old.
• 2020-10-13, Stuff Your Pi-Hole From Anywhere. Fact: “Pi-Hole does its work by acting as your DNS server with a difference, a database of advertising and tracking hosts and domains.” (https://fly.io/blog/stuff-your-pi-hole-from-anywhere/). Use it when: a hobbyist wants a personal DNS ad blocker running near them instead of at home. It is a light, friendly example of a non-web app on Fly.io.
• 2020-10-06, Maps, Apps, and Tracks. Fact: “For displaying the map, we went with Leaflet.js” (https://fly.io/blog/maps-apps-and-tracks/). Use it when: you want a small, story-shaped example (a marathon tracker) to show how quickly a static site plus a mobile data feed can be deployed.
• 2020-09-30, The September Fly Changelog: New Names and Easier Updates. Fact: “all you need to do is run fly version update and the Fly CLI will take care of the rest.” (https://fly.io/blog/the-september-fly-changelog-new-names-and-easier-updates/). Use it when: explaining why older guides say flyctl while newer ones say fly. Today, check the docs for the current update command.
• 2020-09-28, Using Heroku Postgres From A Fly App. Fact: “stay on Hobby Dev for a 1GB database capable of holding up to 10,000 rows to keep things free” (https://fly.io/blog/using-heroku-postgres-from-a-fly-app/). Historical: Heroku’s plan names and limits have almost certainly changed [verify]. Use it when: a customer wants to keep a database at another provider while moving only the app.
• 2020-09-25, Migrating Heroku Database Apps To Fly. Fact: “When you attach a Postgres addon to your Heroku app, it also creates a URL which contains everything you need to connect to the database.” (https://fly.io/blog/migrating-heroku-database-apps-to-fly/). Use it when: a Heroku migration conversation turns to DATABASE_URL handling. It is a good checklist of what to carry over.
• 2020-09-11, Always Be Connecting (with HTTPS). Fact: “Things are different when you bring your own certificate along and attach it to your app.” (https://fly.io/blog/always-be-connecting-with-https/). Historical: it explains HTTP-to-HTTPS upgrades for custom domains on the 2020 platform. Use it when: a customer reports that their custom domain does not redirect to HTTPS. Then verify the current fly.toml option in the docs.
• 2020-09-02, More Fly Answers To Questions. Fact: “unless there is a network service that can be connected to, the health checks will fail and Fly will kill off the app for being apparently faulty.” (https://fly.io/blog/more-fly-answers-to-questions/). Historical: worker processes were not yet supported then. Use it when: a customer asks why a non-HTTP or batch app keeps getting restarted. The health-check lesson still helps, but check the current docs.
• 2020-08-26, Flyctl Builtins - The Fly Changelog for August. Fact: “No need for a Dockerfile - just init and deploy.” (https://fly.io/blog/flyctl-builtins-the-fly-changelog-for-august/). Historical: builtins were an old flyctl feature. Use it when: a user finds a guide that mentions builtin builders and wonders why they are missing.
• 2020-07-29, Sandboxing and Workload Isolation. Fact: “we use Firecracker, the virtualization engine behind Amazon” Lambda and Fargate (https://fly.io/blog/sandboxing-and-workload-isolation/). Use it when: a security reviewer asks why Fly.io chose microVMs over containers or gVisor. The post walks the whole isolation spectrum and is the best long-form answer.
• 2020-07-27, Serve small with Fly.io and GoStatic. Fact: “For GoStatic, the image is an unchunky 6MB.” (https://fly.io/blog/serve-small-with-fly-io-and-gostatic/). Use it when: a customer wants the smallest possible static site and asks about image size and cost.
• 2020-07-21, Hugo’s There - Flying with Hugo and Caddy. Fact: the Dockerfile starts with “FROM klakegg/hugo:0.74.0-onbuild AS hugo” (https://fly.io/blog/hugo-s-there-flying-with-hugo-and-caddy/). Historical: image tags and flyctl init flags are old. Use it when: someone asks for a multi-stage Docker build pattern for a static site generator.
• 2020-07-10, Flyctl Evolved - Fly Changelog. Fact: with the apps subcommand deprecated, “now all its commands have top level commands of their own” (https://fly.io/blog/flyctl-evolved-fly-changelog/). Historical: flyctl v0.0.137 naming. Use it when: a customer pastes an old command like flyctl apps create and it does not work.
• 2020-07-01, Run Apollo Server Close to Your Users. Fact: “Fly.io can run API servers close to users.” (https://fly.io/blog/run-apollo-graphql-close-to-your-users/). Use it when: you need the original “CDN for your API” pitch. The post is short and points to an Apollo plus Redis guide.
• 2020-06-25, How CDNs Generate Certificates. Fact: “LetsEncrypt does domain-validated certificates, based simply on proof of ownership of a domain, and is driven by a protocol called ACME.” (https://fly.io/blog/how-cdns-generate-certificates/). Use it when: someone asks how certificates are issued for custom domains at the edge. The post explains the ACME challenge types and why SNI challenges are hard on shared hosting.
• 2020-06-23, Flyctl meets JSON. Fact: “This new flag attempts to present all output from flyctl as JSON.” (https://fly.io/blog/flyctl-meets-json/). Use it when: a customer wants to script flyctl in CI. Check that --json still behaves this way in the current docs.
• 2020-06-09, Fly Changelog for 9th June. Fact: “Flyctl will now install in $HOME/.fly/bin (or $FLYCTL_INSTALL/bin if $FLYCTL_INSTALL is set).” (https://fly.io/blog/fly-changelog-9th-june/). Historical: install paths may have changed. Use it when: an old install script or PATH problem shows up in a support ticket.
• 2020-05-29, Fly Changelog for 29th May. Fact: the new commands “Instructs the Fly platform to pause (remove all running instances) and resume (start up one running instance) of an application.” (https://fly.io/blog/fly-changelog-may-29th-2020/). Historical: pause and resume were replaced by later scaling models. Use it when: dating the start of park an app to save cost.
• 2020-05-28, Fly - Now With Power Pause. Fact: resume works by “bringing just one instance back, even if the application was originally deployed across multiple regions.” (https://fly.io/blog/fly-now-with-power-pause/). Historical: the 2020 app model. Use it when: you want the original pause and resume design intent.
• 2020-05-20, WebSockets and Fly. Fact: “The fly.toml file contains all the configuration information about how this app should be deployed” (https://fly.io/blog/websockets-and-fly/). Use it when: a customer asks whether WebSockets work on Fly.io. The post answers yes and walks a chat demo. Its fly.toml syntax is old, so check the current reference.
• 2020-05-19, Mux, Fly, Wocket and RTMP. Fact: “Streaming via RTMP is how you stream to Twitch, Youtube Live, Facebook Live, and other live streaming platforms.” (https://fly.io/blog/mux-fly-wocket-and-rtmp/). This is a guest post by a Mux author, so the words are theirs. Use it when: a media customer wants a proof of concept for browser-to-RTMP streaming.
• 2020-05-15, Fly Changelog May 15th 2020. Fact: flyctl v0.0.122 shipped “New scaling mechanism and scaling commands implemented.” (https://fly.io/blog/fly-changelog-may-15th-2020/). Historical. Use it when: a customer cites autoscale from v0.0.121, which this release removed.
• 2020-05-14, Deno on Fly. Fact: with a Dockerfile “you can get quite the build time performance boost and a smaller image file to boot.” (https://fly.io/blog/deno-on-fly/). Use it when: weighing buildpacks against a Dockerfile for any runtime. The tradeoff described still holds in general.
• 2020-05-13, Updating Scale. Fact: “The new system is based on a pool of regions where the application can be run.” (https://fly.io/blog/updating-scale/). Historical: this scaling model predates Machines and today’s fly scale commands. Use it when: explaining why very old scaling docs mention region pools.
• 2020-05-01, Fly Changelog 1st May 2020. Fact: flyctl auth docker “allows users to deploy images directly to fly by adding registry.fly.io to the docker daemon” (https://fly.io/blog/fly-changelog-1st-may-2020/). Use it when: tracing where the registry.fly.io registry started.
• 2020-04-23, Deno on Fly using Buildpacks. Fact: “Now, you can configure, build and deploy Deno code in just two commands” (https://fly.io/blog/deno-on-fly-using-buildpacks/). A very short post, mostly a pointer. Use it when: a Deno developer asks about the first buildpack, and then point them to current docs.
• 2020-04-20, Imaginary on Fly, just One-click. Fact: the page itself carries a notice, “Warning: This document is old! It is likely wrong in some important way.” (https://fly.io/blog/imaginary-on-fly-just-one-click/). Use it when: someone asks about one-click launchers or revenue sharing with open source projects. Do not rely on any detail without checking.
• 2020-04-17, Fly Changelog 17th April 2020. Fact: “flyctl is packaged for Arch Linux now.” (https://fly.io/blog/fly-changelog-17th-april-2020/). Use it when: a Linux user asks where community packaging began. Not useful for current install steps.
• 2020-04-09, Fly Changelog 9th April 2020. Fact: “Setting environment variable DOCKER_BUILDKIT to 1 will enable use of the v2 buildkit backend which performs async parallel builds.” (https://fly.io/blog/fly-changelog-9th-april-2020/). Historical: the default was 0 then. Use it when: a build is slow and an old guide suggests BuildKit.
• 2020-04-08, Powerbuilding with Fly. Fact: “The ARG command makes a variable called NGINX_PORT and sets it to a default of 8080.” (https://fly.io/blog/powerbuilding-with-fly/). Use it when: a customer needs to pass a build argument through --build-args into a runtime variable. The Docker ARG and ENV pattern is timeless; check current flag names.
• 2020-04-06, Fly Answers More Questions. Fact: “Going beyond those maximums means that incoming requests will automatically be dropped.” (https://fly.io/blog/fly-answers-more-questions/). Historical: about per-region and global instance caps. Use it when: a customer worries about a surprise bill from runaway scaling. Check current concurrency and scaling limits in the docs.
• 2020-03-26, Making Datasets Fly with Datasette and Fly. Fact: “It all hinges on SQLite - essentially, you load up an SQLite database with data and then hand it to Datasette which presents it through a web site, to the world.” (https://fly.io/blog/making-datasets-fly-with-datasette-and-fly/). Use it when: a data journalist or analyst wants a read-only data site with no database server.
• 2020-03-23, Continuous Deployment with GitLab. Fact: “To deploy to Fly you essentially need four things” (https://fly.io/blog/continuous-deployment-with-gitlab/). They are the app, a runnable flyctl, a fly.toml and a Fly API token, as the post lists them. Use it when: a customer asks how to set up CI deploys on another platform. The shape holds, but the token type and CLI install differ today.
• 2020-03-18, Fly Answers Questions. Fact: “flyctl config save -a will retrieve the last used configuration” (https://fly.io/blog/fly-answers-questions/). Use it when: a customer lost their fly.toml. Confirm the command in the current docs.
• 2020-03-17, Scaling Fly for All. Fact: the post warns “Update 15/May/2020: The contents of this article have been superceded by a new scaling system on Fly.” (https://fly.io/blog/scaling-fly-for-all/). Use it when: you find this old scaling article in a search and need to say it is outdated. Send customers to the docs instead.
• 2020-03-09, How to do Custom Domains with Fly. Fact: the speedrun includes “Run flyctl certs create -a custom-quartz example.com” (https://fly.io/blog/how-to-custom-domains-with-fly/). Historical: the same flow of listing IPs, adding DNS records and creating a certificate survives in spirit. Use it when: you want the original custom-domain story, then check the current certificate docs.
• 2020-02-28, Fly Friday - News and Tips. Fact: “Firefox is switching DNS over HTTPS (DoH) on by default in the USA.” (https://fly.io/blog/fly-friday-feb28-news/). Use it when: you want a dated snapshot of early community news, including Turboku on Product Hunt and shell tab completion.
• 2020-02-25, GraphQL, Hasura and Fly. Fact: “Hasura gives you an open source GraphQL backend which can make it simple to query PostgreSQL by helping you map all your schemas and roles.” (https://fly.io/blog/graphql-hasura-and-fly/). Use it when: a team wants a GraphQL layer over Postgres. A short pointer post, so read the linked guide.
• 2020-02-21, Fly Friday - Customizing with Dockerfiles. Fact: the stock httpd image, “when run, serves up files from its /usr/local/apache2/html.” (https://fly.io/blog/fly-friday-customizing-with-dockerfiles/). Use it when: a newcomer asks the simplest way to put their own content on a stock Docker image.
• 2020-02-14, Fly Friday - Flyctl and Ports. Fact: “Setting -p with a numeric value automatically sets the internal port of the generated fly.toml configuration file.” (https://fly.io/blog/fly-friday-flyctl-and-ports/). Use it when: an app cannot be reached because the internal port does not match what the image listens on. That mismatch is still a common cause.
• 2020-02-10, Simpler Fly deployments for NodeJS, Rails, Go, and Java. Fact: the feature is “support for Cloud Native Buildpacks” (https://fly.io/blog/simpler-fly-deployments-nodejs-rails-golang-java/). Historical: the flyctl init --builder flow is long gone. Use it when: explaining how Fly.io first removed the need to write a Dockerfile.
• 2020-02-05, Turboku - The Art Of Faster Heroku Apps. Fact: “What we do is take your Heroku web dynos and turn them into Fly applications automatically.” (https://fly.io/blog/turboku/). Historical: a 2020 migration pitch. Use it when: a Heroku user asks about the earliest Heroku-to-Fly path, then send them to current migration docs.
• 2020-01-29, Command Lines, Flyctl and Fly. Fact: “the command line is king.” (https://fly.io/blog/command-lines-flyctl-and-fly/). Use it when: someone asks why Fly.io leads with flyctl rather than a dashboard. This is the launch-era statement of that stance.
• 2020-01-22, Welcome To Fly In 2020. Fact: “Welcome to Fly, the home of the Fly Global Application Platform.” (https://fly.io/blog/welcome-to-fly/). The earliest post in the archive and only a few lines long. Use it when: you need the date the blog started.