<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Embedded Databases on App Coding</title>
    <link>https://appcoding.com/tags/embedded-databases/</link>
    <description>Recent content in Embedded Databases on App Coding</description>
    <generator>Hugo</generator>
    <language>en-us</language>
    <lastBuildDate>Fri, 09 Oct 2026 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://appcoding.com/tags/embedded-databases/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>40 Projects Worth Building: SQLite for X, Tiny Infrastructure, MCP Tools and Edge Systems</title>
      <link>https://appcoding.com/40-projects-worth-building-sqlite-for-x-tiny-infrastructure-mcp-tools-and-edge-systems/</link>
      <pubDate>Fri, 09 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/40-projects-worth-building-sqlite-for-x-tiny-infrastructure-mcp-tools-and-edge-systems/</guid>
      <description>&lt;p&gt;The most promising territory for a small team isn&amp;rsquo;t another large framework. It&amp;rsquo;s the opposite: infrastructure software you can explain in one sentence, ship as one binary or embed as one library, run with almost no operational burden, and that solves one irritating problem unusually well. SQLite and nginx are the right mental models because their appeal is architectural, not just functional: small surface area, predictable behavior, few dependencies, easy deployment, and usefulness far beyond the original use case. (More on that in &lt;a href=&#34;https://appcoding.com/one-binary-one-file-no-daemon-the-sqlite-and-nginx-pattern-as-a-product-strategy/&#34;&gt;the SQLite and nginx pattern as a product strategy&lt;/a&gt;.)&lt;/p&gt;</description>
    </item>
    <item>
      <title>A Background Job Queue in One SQLite File Covers What Most Apps Deploy Redis For</title>
      <link>https://appcoding.com/a-background-job-queue-in-one-sqlite-file-covers-what-most-apps-deploy-redis-for/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/a-background-job-queue-in-one-sqlite-file-covers-what-most-apps-deploy-redis-for/</guid>
      <description>&lt;p&gt;A signup handler has to send a welcome email, and sending it inline puts a third-party API call inside your request. So you move it into a background job, and the usual next step is Redis, a client library, a worker process, a dashboard, and a note in the deploy docs about what happens to queued jobs when Redis restarts without persistence. If the app runs on one machine, you&amp;rsquo;ve added a second stateful service to look after a table&amp;rsquo;s worth of data.&lt;/p&gt;</description>
    </item>
    <item>
      <title>A Feature Store Small Enough to Embed: Point-in-Time Reads for Local and Edge ML</title>
      <link>https://appcoding.com/a-feature-store-small-enough-to-embed-point-in-time-reads-for-local-and-edge-ml/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/a-feature-store-small-enough-to-embed-point-in-time-reads-for-local-and-edge-ml/</guid>
      <description>&lt;p&gt;A churn model looks excellent in the notebook and mediocre in production. The model isn&amp;rsquo;t broken. The training table computed &lt;code&gt;orders_7d&lt;/code&gt; with a rolling window over the full history, so some rows counted orders placed after the label date. The serving code, written later in another language, counts a calendar week instead of seven days. One feature, two definitions, and a quiet look into the future. Those are the two bugs a feature store exists to prevent: training-serving skew and label leakage.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Embedded Vector Search Is Crowded: What a One-File Vector Database Needs to Stand Out</title>
      <link>https://appcoding.com/embedded-vector-search-is-crowded-what-a-one-file-vector-database-needs-to-stand-out/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/embedded-vector-search-is-crowded-what-a-one-file-vector-database-needs-to-stand-out/</guid>
      <description>&lt;p&gt;You have 40,000 support articles and an app that should offer &amp;ldquo;similar articles&amp;rdquo;. Embedded at 768 dimensions in float32, that&amp;rsquo;s 40,000 × 768 × 4 bytes, about 123 MB of vectors. The standard advice is to stand up a vector database: a service, a port, credentials, a client library and a backup story for 123 MB. A file would do.&lt;/p&gt;&#xA;&lt;p&gt;Below a few million vectors the server is the overhead, which is why the embedded field filled up fast. So the useful question is what a newcomer brings that the free libraries don&amp;rsquo;t. My answer is one sharp edge you can state in a sentence, plus measurements the others leave you to make yourself.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Kafka for One Machine: An Embedded Event Log With Offsets, Compaction and No Broker</title>
      <link>https://appcoding.com/kafka-for-one-machine-an-embedded-event-log-with-offsets-compaction-and-no-broker/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/kafka-for-one-machine-an-embedded-event-log-with-offsets-compaction-and-no-broker/</guid>
      <description>&lt;p&gt;A desktop app wants an undo history that survives a crash. An edge gateway buffers sensor readings while its uplink is down and has to replay them, in order, once the link is back. An AI agent writes down every action it takes so a bad run can be replayed later. All three are the same data structure: an append-only sequence of records, plus readers that remember where they stopped. Kafka is that structure, and also a cluster, partitions and the people who tune them.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Redis Semantics Without Redis: An Embedded State Engine for Counters, Leases and TTLs</title>
      <link>https://appcoding.com/redis-semantics-without-redis-an-embedded-state-engine-for-counters-leases-and-ttls/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/redis-semantics-without-redis-an-embedded-state-engine-for-counters-leases-and-ttls/</guid>
      <description>&lt;p&gt;A command-line tool should run only one copy of its nightly export at a time. A small web app wants to cap each user at 60 requests a minute. A desktop app needs to remember when it last synced. All three are state: an integer, a timestamp, an owner. All three usually get solved by adding Redis, because Redis has the verbs for them: &lt;code&gt;INCR&lt;/code&gt;, &lt;code&gt;SET NX PX&lt;/code&gt;, &lt;code&gt;EXPIRE&lt;/code&gt;. The app needed the verbs and got a server along with them, a port and a persistence config included.&lt;/p&gt;</description>
    </item>
    <item>
      <title>SQL and Key-Value Over the Same Bytes: An Old Database Idea Worth Making Small</title>
      <link>https://appcoding.com/sql-and-key-value-over-the-same-bytes-an-old-database-idea-worth-making-small/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/sql-and-key-value-over-the-same-bytes-an-old-database-idea-worth-making-small/</guid>
      <description>&lt;p&gt;A sensor node writes a reading every few seconds. The firmware wants one thing from storage: put a record by key, get it back by key, as fast as the flash allows. The dashboard on the gateway wants something else, like average temperature by sensor by hour, joined to a table of sites. The usual answer is two databases with a translation job between them, a key-value store on the device and SQLite or Postgres upstream. Then comes a year of debugging the translation: a unit that changed, a row that arrived twice, a field the device encodes one way and the gateway reads another.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Store Changes Instead of Current Rows: An Embedded Database Built Around History</title>
      <link>https://appcoding.com/store-changes-instead-of-current-rows-an-embedded-database-built-around-history/</link>
      <pubDate>Mon, 05 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/store-changes-instead-of-current-rows-an-embedded-database-built-around-history/</guid>
      <description>&lt;p&gt;A support ticket asks two plain questions: which plan was customer 4411 on when the August invoice went out, and who moved them off it? The &lt;code&gt;customers&lt;/code&gt; table can&amp;rsquo;t answer either. It holds today&amp;rsquo;s row. The audit table someone added two years ago holds most of the story, apart from the week a data fix ran a bulk &lt;code&gt;UPDATE&lt;/code&gt; in raw SQL and skipped the ORM callbacks that write the audit rows.&lt;/p&gt;</description>
    </item>
    <item>
      <title>AltSql: Gives IoT Devices a 15 KB Database That Keeps Working When the Link Drops</title>
      <link>https://appcoding.com/altsql-gives-iot-devices-a-15-kb-database-that-keeps-working-when-the-link-drops/</link>
      <pubDate>Fri, 02 Oct 2026 00:00:00 +0000</pubDate>
      <guid>https://appcoding.com/altsql-gives-iot-devices-a-15-kb-database-that-keeps-working-when-the-link-drops/</guid>
      <description>&lt;p&gt;Anyone who has built the software side of a connected product knows the integration job. The device keeps its readings and settings in one format and the gateway or cloud service wants those same values as rows in a SQL database. Somebody writes a converter. Then somebody has to keep that converter alive for as long as the device stays in the field, which for industrial equipment or embedded systems can easily be ten years. The converter has to handle offline periods, retries, out-of-order updates, and the device&amp;rsquo;s own data format changing over time.&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
