<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Harper Ward</title>
    <description>The latest articles on DEV Community by Harper Ward (@harper_ships).</description>
    <link>https://dev.to/harper_ships</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4210908%2F965a825c-4bbe-4e31-8886-4f4e810e18db.jpg</url>
      <title>DEV Community: Harper Ward</title>
      <link>https://dev.to/harper_ships</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/harper_ships"/>
    <language>en</language>
    <item>
      <title>Cloud Run cold starts: what I measured and what I changed</title>
      <dc:creator>Harper Ward</dc:creator>
      <pubDate>Thu, 29 Oct 2026 01:20:36 +0000</pubDate>
      <link>https://dev.to/harper_ships/cloud-run-cold-starts-what-i-measured-and-what-i-changed-573</link>
      <guid>https://dev.to/harper_ships/cloud-run-cold-starts-what-i-measured-and-what-i-changed-573</guid>
      <description>&lt;p&gt;We moved a small API to Cloud Run and immediately started getting complaints about the first request of the day being slow. So I spent a week measuring cold starts instead of guessing.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I measured
&lt;/h2&gt;

&lt;p&gt;Not with synthetic benchmarks, but with the actual requests: the service logs a timestamp on entry, and I recorded the gap between the request arriving at the load balancer and the first line of our handler executing. That includes platform time we can't control, which is the honest number a user experiences.&lt;/p&gt;

&lt;p&gt;I ran this for a week, then made one change at a time and watched the same metric.&lt;/p&gt;

&lt;h2&gt;
  
  
  What moved the needle
&lt;/h2&gt;

&lt;p&gt;Container size was the biggest single factor. Our first image was built from a full node image with dev dependencies, about 900MB. A multi-stage build with a distroless base brought it to under 100MB, and the p50 cold start dropped from roughly 4 seconds to under 2.&lt;/p&gt;

&lt;p&gt;Minimum instances made the tail disappear. We set &lt;code&gt;--min-instances=1&lt;/code&gt; on the service that humans actually wait on, and kept zero for the internal batch jobs. The cost difference for a small instance was about the same as one coffee a week, which I'm happy to pay for not getting "is it down?" messages.&lt;/p&gt;

&lt;p&gt;Startup work was the sneaky one. We had a config loader that fetched a dozen secrets over the network on boot. Moving those to environment variables configured at deploy time removed almost a second, and made the service start deterministically.&lt;/p&gt;

&lt;h2&gt;
  
  
  What didn't help
&lt;/h2&gt;

&lt;p&gt;More memory. I tried bumping to a larger instance class and the cold start barely changed. It does help throughput, not startup.&lt;/p&gt;

&lt;p&gt;Parallelism settings: they change how many requests an instance handles, not how fast it starts. Worth tuning separately, and only if you have the traffic to justify it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The current setup
&lt;/h2&gt;

&lt;p&gt;Small multi-stage image, secrets via env vars, min instances of 1 on the user-facing API, zero everywhere else, and an alert when the p95 startup exceeds our old baseline. Nothing clever. The main lesson was that cold starts are mostly a build-and-boot problem, and the platform will only fix the part it owns.&lt;/p&gt;

</description>
      <category>cloud</category>
      <category>devops</category>
      <category>performance</category>
    </item>
    <item>
      <title>On-call handoff notes that people actually read</title>
      <dc:creator>Harper Ward</dc:creator>
      <pubDate>Wed, 28 Oct 2026 04:45:01 +0000</pubDate>
      <link>https://dev.to/harper_ships/on-call-handoff-notes-that-people-actually-read-5fl7</link>
      <guid>https://dev.to/harper_ships/on-call-handoff-notes-that-people-actually-read-5fl7</guid>
      <description>&lt;p&gt;We used to write long handoff documents that nobody read. Now we write three lines and people actually use them.&lt;/p&gt;

&lt;p&gt;The template:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;What's on fire (or nothing)&lt;/li&gt;
&lt;li&gt;What I changed that you should know about&lt;/li&gt;
&lt;li&gt;What I'm worried about&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That's it. Three lines, posted in the on-call channel at handoff.&lt;/p&gt;

&lt;p&gt;The surprising part: the third line is the most valuable. "I'm worried about the cron job that runs at 3am" has saved us several times.&lt;/p&gt;

&lt;p&gt;We also added a rule: if you had a quiet week, say so explicitly. Silence is ambiguous; "nothing happened" is information.&lt;/p&gt;

&lt;p&gt;Side quest: reading SQLite internals. WAL mode is a great case study in making a simple thing predictable.&lt;/p&gt;

</description>
      <category>devops</category>
      <category>oncall</category>
      <category>teamwork</category>
    </item>
    <item>
      <title>Reading SQLite's WAL: a DevOps detour</title>
      <dc:creator>Harper Ward</dc:creator>
      <pubDate>Tue, 27 Oct 2026 15:49:49 +0000</pubDate>
      <link>https://dev.to/harper_ships/reading-sqlites-wal-a-devops-detour-59b5</link>
      <guid>https://dev.to/harper_ships/reading-sqlites-wal-a-devops-detour-59b5</guid>
      <description>&lt;p&gt;A small service started getting &lt;code&gt;database is locked&lt;/code&gt; errors under load. The fix was a one-line change to the busy timeout, but understanding &lt;em&gt;why&lt;/em&gt; took longer.&lt;/p&gt;

&lt;p&gt;What I learned about SQLite's WAL mode:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Writers append to a WAL file; readers don't block writers&lt;/li&gt;
&lt;li&gt;Checkpoints move WAL pages back into the main database&lt;/li&gt;
&lt;li&gt;A long-running reader can delay a checkpoint and grow the WAL&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That last point explained our problem: an analytics query held a read transaction open, and the WAL grew until the disk alarm fired. We capped the query and moved it to a replica.&lt;/p&gt;

&lt;p&gt;I keep coming back to SQLite because the more I learn, the more predictable it gets. That's a rare property in infrastructure.&lt;/p&gt;

</description>
      <category>sqlite</category>
      <category>devops</category>
      <category>database</category>
    </item>
  </channel>
</rss>
