<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>afterpatch on Aftermarket.dev</title>
    <link>https://aftermarket.dev/tags/afterpatch/</link>
    <description>Recent content in afterpatch on Aftermarket.dev</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Wed, 21 Oct 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://aftermarket.dev/tags/afterpatch/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Aftermarket Fixes Proxy Answers Cut Off Under Load</title>
      <link>https://aftermarket.dev/aftermarket-fixes-proxy-answers-cut-off-under-load/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/aftermarket-fixes-proxy-answers-cut-off-under-load/</guid>
      <description>Aftermarket 0.7.1 is a fix release, and the bug it fixes was hiding in plain sight. For a couple of days CI failed now and then in the random pass-through tests, with an &amp;ldquo;unexpected EOF&amp;rdquo; while reading an answer. The same tests passed every time on the build machine. It got written off as a flaky test.
It wasn&amp;rsquo;t. Every failure was on the call through the proxy, never on the direct one.</description>
    </item>
    
    <item>
      <title>Aftermarket Hardens Patch, Adapt and Record Against Stalled and Cut Off Uploads</title>
      <link>https://aftermarket.dev/aftermarket-hardens-patch-adapt-and-record-against-stalled-and-cut-off-uploads/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/aftermarket-hardens-patch-adapt-and-record-against-stalled-and-cut-off-uploads/</guid>
      <description>Aftermarket 0.7.2 is about one unglamorous thing: what a proxy does with a request body that doesn&amp;rsquo;t arrive the normal way. It might come slowly, stop halfway, get cut off, or still be on its way when the upstream has already answered.
That sounds like an edge case. It isn&amp;rsquo;t, once a proxy sits in front of real clients. Phones lose signal mid-upload. Scripts get killed. Some servers answer 401 before reading a byte of the body.</description>
    </item>
    
    <item>
      <title>Case Study: Fixing a Moved Exchange Rate Endpoint With Two AfterPatch Rules</title>
      <link>https://aftermarket.dev/case-study-fixing-a-moved-exchange-rate-endpoint-with-two-afterpatch-rules/</link>
      <pubDate>Tue, 20 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/case-study-fixing-a-moved-exchange-rate-endpoint-with-two-afterpatch-rules/</guid>
      <description>This is a worked case on a small stand-in service, built to look like a common kind of break. Every command and every line of output below comes from a real run of aftermarket 0.3.0.
What broke An app shows exchange rates. It calls GET /v1/rate?from=EUR&amp;amp;to=USD and reads rate from the answer. It&amp;rsquo;s installed on devices nobody can update this week.
The rate provider shipped a new version, and three things changed at once:</description>
    </item>
    
    <item>
      <title>AfterPatch Released as the First Aftermarket Tool</title>
      <link>https://aftermarket.dev/afterpatch-released-as-the-first-aftermarket-tool/</link>
      <pubDate>Mon, 19 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/afterpatch-released-as-the-first-aftermarket-tool/</guid>
      <description>AfterPatch 0.1.0 is out. It&amp;rsquo;s the first working tool in the Aftermarket family: a small reverse proxy that repairs HTTP traffic between a client and a service, with rules you can read, and without changing either side.
You put it in front of a service, point the client at it, and give it a YAML file of rules. A rule says which traffic it applies to (method, path, query, headers, status, content type) and what to change: set or remove headers, rewrite the path, or rename, copy, set and delete JSON fields in the request or the response.</description>
    </item>
    
    <item>
      <title>How AfterPatch Was Tested Before Its First Release</title>
      <link>https://aftermarket.dev/how-afterpatch-was-tested-before-its-first-release/</link>
      <pubDate>Mon, 19 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterpatch-was-tested-before-its-first-release/</guid>
      <description>A repair tool earns trust in one way: it has to leave alone everything it isn&amp;rsquo;t supposed to touch. So most of the AfterPatch tests don&amp;rsquo;t check the repairs. They check what happens around them.
Every number here comes from the recorded results in the repository&amp;rsquo;s test/results folder, written by a script, not by hand.
The headline test The first test sends 400 random requests straight to a test server, then sends the same 400 through AfterPatch.</description>
    </item>
    
    <item>
      <title>Why Aftermarket starts with one patch</title>
      <link>https://aftermarket.dev/why-aftermarket-starts-with-one-patch/</link>
      <pubDate>Mon, 19 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/why-aftermarket-starts-with-one-patch/</guid>
      <description>A software aftermarket sounds like a place where you can bolt on anything. That makes a good name and a terrible first specification. A pile of adapters, shims and rescue tools could easily turn into a pile of unfinished promises.
So the first question is a small one. Can a developer fix one broken HTTP contract without touching either application? And can someone else read that fix six months later and understand it?</description>
    </item>
    
  </channel>
</rss>
