• Skip to main content
  • Skip to secondary menu
  • Skip to footer

Market Analysis

Connecting the Dots, Quantifying Technology Trends & Measuring Disruption

  • AI Market Analyzer
  • Tech News
    • Project Dashboard
  • Domain Marketplace
  • Sponsored Post
  • About
  • Contact

AltSql.com Investment Proposal for an Open Source Data Engine and Database for Connected Devices

November 18, 2026

AltSql.com builds two open-source products for connected devices: AltSql Core, a small data engine with key-value and time-series records on the device and SQL on the gateway, and AltSql DB, a gateway database that keeps a whole fleet in one file. Both are released under the Apache License 2.0. The company earns from what sits on top: proprietary versions, premium add-ons and modules, and customization and support for every build. The premise: devices that keep working offline, decide on the spot, send less over the network and share one format from sensor to cloud, with no translator in between. Both products work today as a tested Alpha. Next come real chips and a Learned Query Optimizer (LQO), a paid add-on that lets the engine learn from its own data.

Project links: the project site is altsql.com, the code is on GitHub, and AltSql is listed with the other open-source projects on SoftDevStudio.com.

VERSION Draft v0.8, 5 October 2026
STAGE Alpha engine and database, open source on GitHub, built and tested in simulation (TRL 4); the Beta on real chips is next
MODEL Open core: the engine and the database are free under the Apache License 2.0; paid add-ons, customization, support and maintenance sit on top
ROUND Seed, $7 million, more likely a priced equity round than a SAFE
EXIT SCENARIO An early acquisition by the end of year one, most likely by an AI infrastructure company

Alpha figures were measured in simulation in September and October 2026, except those marked computed. Market size and growth are our own estimates. Figures marked illustrative are planning arithmetic only, and the exit scenarios describe possibilities.

Executive Summary

AltSql.com makes two open-source products for connected devices. AltSql Core is a small data engine that keeps and queries data on the device itself: key-value and time-series storage on a microcontroller, SQL on the gateway, the same records on both. AltSql DB is a database for the gateway that keeps a whole fleet in one file, with SQL and direct key-value calls designed together, sharing storage and transactions. Both are public on GitHub under the Apache License 2.0. The business is what sits on top: proprietary versions, premium add-ons and modules under commercial licenses, and the fitting. Every device has its own chip, flash memory, sensors, radio link and industry rules, and AltSql.com customizes the engine to all of them and supports it for the ten or more years the product stays in the field. The next stage adds a Learned Query Optimizer (LQO), a paid add-on that lets the engine learn from its own data and adjust to the device’s situation, within limits the application sets.

An early exit is a realistic scenario. We see a path to an acquisition by the end of the first year, most likely by an AI infrastructure company that wants a data layer for AI on devices. Chip vendors, cloud providers, embedded software companies and industrial groups are other possible buyers. If no early offer beats the plan, the round carries the company to a Series A (Sections 12 and 15).

THE PITCH

A small, well-tested engine and database, free and open source. The paid part sits on top: add-ons, customization for each chip, sensor and industry, and support for the life of the product. What other companies see as a hassle, we see as the opportunity.

The Premise

Remote devices should think for themselves. A device that keeps and queries its own data decides on the spot, keeps working when the link drops and sends upstream only what matters, in one format from sensor to cloud. The Alpha demo tests each part (Section 4).

More autonomy
Devices keep working and deciding when the connection drops
Less bandwidth
Results and alerts go upstream instead of every raw reading
Local decisions
Devices act on their own data, with no round trip to the cloud
No translator
One format and one sync protocol from sensor to cloud

Free Code, Paid Add-ons and Services

The code is free and the work around it is paid. A proprietary engine from an unknown company has little chance of reaching the market, and embedded teams try free code before they buy anything, so open source lowers the cost of trying. Revenue comes from what sits on top. What a device maker needs is a data layer that fits the product, survives power cuts, passes audits and keeps working for a decade. Most vendors sell a general engine and leave the fitting to the customer. AltSql.com sells the fitting and the years of support that follow. A flexible platform will make each customization fast for us and valuable to the customer: build switches (working today), set-up files and a generator (from the Beta), a growing library of proven chip and industry profiles, and a lab that tests every build on real boards. The platform pieces that go beyond the open code are paid add-ons or services. That is where the money is (Sections 6 and 10) and where the moat is (Section 9).

Proof So Far

  • A working engine. One C file of 3,907 lines with key-value, time-series, SQL and device-to-gateway sync, and no dynamic memory. On a Cortex-M4 it takes about 7.2 KB with key-value only, 15.0 KB as a sensor build and 38.1 KB with SQL.

  • Open source on GitHub. AltSql Core and AltSql DB are public at github.com/AltSql/altsql under the Apache License 2.0, with the notice “Copyright 2026 AltSql.com”. Release 0.1.0-alpha went public on 2 October 2026 and 0.2.0-alpha on 5 October 2026, with the code, the core tests, a demo and Linux x86-64 binaries.

  • Tested hard, in simulation. 104,942 functional checks, 400,000 simulated power cuts and 28 million fuzzed inputs, with no acknowledged data lost. The tests caught all 16 bugs planted to try them, 14 of them on the first run.

  • The database holds up. In AltSql DB 0.2, 100,000 random steps run as SQL and as direct calls gave the same answers and refusals, and the two files ended identical byte for byte. Over a link that lost, repeated and reordered 8,888 batches, every record was applied exactly once, where the 0.1 way lost 16,109.

  • One engine, three industries. In the demo a machine sensor, a truck temperature logger and a soil sensor differ only in set-up. Each made its own decisions on the device, even with its link down, and sent 1.1 to 6.8 KB over its constrained link, where every record would have taken 86 to 180 KB (the soil sensor’s figure is computed).

  • Honest status. Technology readiness level 4: validated in a simulated lab. Everything runs on a PC in simulation, and nothing has run on a microcontroller or a gateway yet. The Beta changes that in about 16 weeks.

What Comes Next

The Beta puts the engine on real boards from five microcontroller families and the database on a Linux gateway, cuts the boards’ power 10,000 times each and runs three industry devices for a week. Release 0.3 of AltSql DB is planned to add statement savepoints and secondary indexes. The Advanced Beta then adds the Learned Query Optimizer (LQO), an optional paid add-on that reads the device’s situation and chooses what to keep, what to send and how to answer, within limits the application sets. A first test on the Alpha engine, with summaries kept in their own storage area, answered an hourly query 38 times faster with the same result, up to rounding.

Why Now

AI is moving into machines. NVIDIA’s chief executive said in March 2026 that “every industrial company will become a robotics company”, and the companies that build AI infrastructure are buying their way to the edge (Section 15). The EU Cyber Resilience Act makes device makers handle vulnerabilities for the whole support period, with reporting duties since 11 September 2026. Microsoft and MongoDB have left the device tier, and in August 2026 Amazon agreed to acquire DuckLabs, the company behind DuckDB (Section 2).

Model and Ask

The model is open core. The engine and the database are free under the Apache License 2.0. Customers buy what sits on top: proprietary versions, premium add-ons and modules under add-on licenses, customization projects, support and long-term maintenance, fleet services and, later, certified builds and learned model packs (Section 10). We are raising a $7 million seed round, more likely a priced equity round than a SAFE, for about 24 months of runway, 60% of it for engineering. By month 12 the plan makes the company ready for an early sale. By month 24 it delivers a v1.0 with its first commercial add-ons, a library of 30 or more proven targets, 10 to 20 design partners and $0.5 to 1 million in annual recurring revenue.

Snapshot

Item Detail
Category Open-source data engine and database for IoT and edge devices, with paid add-ons and a customization platform
Model Open core: free code under the Apache License 2.0; paid add-ons, customization, support and maintenance
Stage Alpha built and tested in simulation (TRL 4), open source on GitHub; Beta next; the LQO after it
Edge Free code to try; fast, Lab-proven customization per device, supported for the product’s life
Verticals Machine monitoring, cold chain and agriculture first; energy, buildings and more next
Team About 19 people by month 12, described as roles in Section 13
Round Seed, $7 million, more likely a priced round than a SAFE, about 24 months of runway
Exit Early sale possible by the end of year one, most likely to an AI infrastructure company

The Problem and Why Now

Every Device Is Different

A connected product usually has two computers that handle its data. One is the device, a microcontroller with kilobytes of RAM and flash memory that wears with every erase, where power can vanish mid-write. The other is a gateway that gathers data from many devices and passes it on, often to a cloud.

The hard part is variety. In the Alpha demo a machine sensor reads once a second over Wi-Fi. A truck logger records for two days with coverage only at depots, and it has to prove the cargo stayed cold. A soil sensor lives on one 51-byte radio message a day. A data layer that suits one of them is wrong for the other two.

What varies from one device to the next:

Dimension Range What it changes in the data layer
Chip Cortex-M0+ to M33, RISC-V and Xtensa microcontrollers; Linux gateways Code size, speed, which features fit
Memory From a few KB of RAM to gigabytes Buffers and indexes; how much the device can decide by itself
Flash Internal NOR, external SPI flash, SD cards; write sizes from 1 to 16 bytes Layout, wear and power-loss handling
Operating system Bare metal, FreeRTOS, Zephyr, ESP-IDF, embedded Linux Ports and integration
Sensors and data Temperature, vibration, power, moisture, location; from once a second to once a day Data layout, summaries, retention
Industry rules Alarms, excursion records, audit trails, safety standards Rules on the device, records kept, certification
Link Wi-Fi, cellular, LoRaWAN, satellite, or nothing for days What is sent, when, and in what size

Why No Standard Emerged

Each tool covers a slice of the device world, and none adapts to the rest:

Tier Typical choice Good at Falls short
Device FlashDB, SDK key-value stores, hand-rolled structs in flash Tiny, flash-aware, simple Fixed to one job or one chip family; no queries; every product’s format is different
Device, commercial McObject eXtremeDB, ITTIA DB Lite, Raima Track record, device-to-server features Sold as general products; fitting each device is left to the customer
Gateway SQLite Trusted, full SQL, huge ecosystem Too big for most microcontrollers; device data must be converted first
Cloud IoT platforms and custom pipelines Scale, dashboards Another format and another sync layer; devices treated as mere senders

So every product team writes glue code that converts the device’s format for the gateway’s database. Glue is where format drift and quiet data bugs live, and somebody has to maintain it for the life of the product.

The gap costs more than engineering time. A device that cannot query its own data ships raw readings upstream and waits for another machine to decide. That wastes bandwidth and leaves the device stuck when the link drops. In the Alpha demo the machine sensor’s summaries-only link carried 2.5 KB in an hour, against 96 KB for every record and 191 KB as JSON.

Why Now

1. AI Is Moving Into Machines

NVIDIA’s chief executive said in March 2026 that “every industrial company will become a robotics company”. Models on devices need data on devices: context, recent readings, results and logs that survive power cuts and outages and reach the gateway where models are trained. The companies that build AI infrastructure are moving to the edge, often by acquisition. Qualcomm bought Edge Impulse and agreed to buy Arduino in 2025, and NXP and Nordic Semiconductor bought edge AI teams (Section 15).

2. Regulation Raises the Cost of Every Line of Firmware

The Cyber Resilience Act covers hardware and software with digital elements, including software components sold on their own. Reporting obligations have applied since 11 September 2026, and the main obligations apply from 11 December 2027. Makers must handle vulnerabilities for a support period they state at the time of sale. A small build of a small engine is cheaper to vouch for, and a supplier who does the vulnerability work for the life of the product is worth paying.

3. Big Vendors Are Leaving the Device Tier

MongoDB bought Realm, a mobile database with sync, for $39 million in 2019, and its device sync service reached end of life in September 2025. Microsoft retired Azure SQL Edge, its database for IoT gateways and edge devices, the same month. Whatever their reasons, two of the largest vendors have stepped back from device data, which leaves room for a specialist that makes the tier’s fragmentation its business.

4. Embedded Databases Have Become Strategic

On 26 August 2026 Amazon agreed to acquire DuckLabs, the company behind the embedded analytics database DuckDB. The project itself stays with its nonprofit foundation, so Amazon is buying the team and its know-how. Databases that run inside the application now matter to the largest cloud providers.

5. Proof on Real Chips Is Now the Hard Part

AI-assisted engineering lets a small team write a compact engine, or a port for a new chip, in days, and the Alpha of the AltSql engine was built this way. What stays slow and costly is proof on the real chip: thousands of power cuts, then years of support in the field. That work is the business of AltSql.com (Section 6).

The Engine and the Platform

One Engine, Built in Layers

The AltSql engine, AltSql Core, is one C file of 3,907 lines. It never calls malloc: the device hands it one fixed block of memory at start-up. Build switches turn layers on or off, and code that is switched off is not compiled at all.

Layer What it does Where it runs Cortex-M4 build
Storage base A log of records in flash that spreads wear, survives power cuts and rolls over the oldest rows when full Everywhere Always included
Key-value Settings, calibration values and device state, with a small index in RAM Microcontrollers and up 7.2 KB with storage
Time-series Timestamped readings, range scans and window statistics for rules on the device Sensors and loggers 13.4 KB with the layers below
Sync Records copied to the gateway exactly as stored; resumes after any break; filtered per link Devices and gateways 15.0 KB: the sensor build
SQL and text SELECT with WHERE, GROUP BY, ORDER BY and aggregates; export to plain text and back Gateways and larger devices 38.1 KB: the gateway build

THE SAME RECORDS ON THE DEVICE AND ON THE GATEWAY

Sensor: altsql_append(db, "raw", (int64_t)now, 61.5);
altsql_ts_window(db, "raw", "temp", now - 9, &st);
if (st.count == 10 && st.min > 60.0) fan_on(); /* decided on the device */
Gateway: SELECT time / 3600 AS hour, AVG(temp) FROM raw GROUP BY hour

A device writes with the key-value and time-series layers, and the gateway queries the same records with SQL. There is no export job and no second format to keep in step. The format is defined byte by byte, so it is identical on every chip.

The Gateway Database: AltSql DB

AltSql DB is the database for a gateway that serves a fleet. It keeps the records of all the devices in one file and answers SQL or direct key-value calls (get and put) over the same rows. The two interfaces were designed together and share storage and transactions, and every change to a row goes through one write path, so a refused row changes nothing, whichever interface sent it. Devices running AltSql Core sync into it, and it applies each batch once and in order. It is one C file of 4,504 lines and compiles to 96,821 bytes of code (Section 4).

The Platform Around It

The engine and the database are open source. The platform is how AltSql.com fits them to each device and proves the result, and how each customer project makes the next one faster. The pieces that go beyond the open code are sold as add-ons or services.

Part What it does Free or paid Status
AltSql Core and AltSql DB The engine (key-value, time-series, sync and SQL in one C file) and the gateway database Free, Apache License 2.0 Alpha done and public on GitHub; Beta next
AltSql Studio Turns a short set-up file (chip, flash, memory, data, rules, link) into a customized build, with a report of size, memory and test results Paid add-on A first generator in the Beta; command line by v1.0; web version by month 24
AltSql Lab Development boards for every target, power-cut rigs and endurance runs. Every build is proven here before it ships Internal; the results stay proprietary First power-cut rig in the Beta
AltSql Fleet Ships builds and set-up updates to devices in the field, runs sync to gateways and the cloud, watches storage health Paid add-on Beta in months 12 to 18; generally available by month 24
The library Validated targets (chip, flash, operating system) and profiles (sensors, industries). Studio builds from it, and every customer project adds to it Paid add-on Starts with the Beta’s five boards and three industry devices
The LQO The Learned Query Optimizer: an optional layer that adapts the engine to the device’s situation, within contracts the application sets (Section 5) Paid add-on Concept tested; built after the Beta
Support Updates, security fixes and new flash drivers for each product line, for its whole life Paid service From the first paying customer

How a Device Gets Its Build

STEP 1
Describe the device in a set-up file: chip, flash, memory, data, rules, link
STEP 2
Studio picks the nearest proven target and profile and generates the build
STEP 3
Lab runs it on the matching board: power cuts, endurance, size, memory
STEP 4
Fleet ships it and keeps its set-up current in the field
STEP 5
Support keeps it working for the life of the product

What Gets Customized

Layer of the device What varies How the AltSql engine adapts
Chip Cortex-M0+ to M33, RISC-V, Xtensa; Linux gateways One portable C source; build switches choose the layers; a port per chip family
Memory From under 1 KB of engine RAM (672 bytes on the demo’s soil sensor), plus up to 1.4 KB of stack A memory ceiling fixed at start, with no heap; limits set per device
Flash Internal and external flash, file stores; write sizes of 1 to 16 bytes; sectors from 256 bytes to 64 KB A small driver per flash part and a layout to fit it; the demo’s truck logger uses 64 KB sectors
Sensors and data Readings from once a second to once a day Data layouts, summaries on the device and retention, from sensor profiles
Industry Alarms, excursion records, audit trails, certification Rules and records from industry packs; certified builds later
Link From Wi-Fi to one 51-byte message a day Sync filters and message sizes set to the link
Behavior (Advanced Beta) Battery, coverage, flash wear and the data change over time Contracts in the set-up file and small learned models in the LQO (Section 5)

Proof So Far: The Alpha

The Alpha is the working engine with its tests and a three-industry demo, now joined by the gateway database. The Alpha Report and Beta Roadmap (v0.2) documents the engine in full, and the 0.2 Release Report (v0.1) documents the database and the open-source release. Both give the commands that reproduce every number. The main results:

About 15 KB
sensor build on a Cortex-M4: key-value, time-series and sync
Under 1.1 KB
engine RAM per demo device, plus up to 1.4 KB of stack
400,000
simulated power cuts in one run, with nothing lost
16 of 16
planted bugs caught by the tests
100,000
random steps run as SQL and as direct calls: the same answers, refusals and files
0 lost
records over a link that dropped, repeated and reordered 8,888 batches; the 0.1 way lost 16,109
2 releases
on GitHub: 0.1.0-alpha on 2 October and 0.2.0-alpha on 5 October 2026
17.2%
of SQLite’s code size for the Core gateway build and AltSql DB together (computed)

What Was Measured

Area Result
Code size Compiled for four microcontroller families (Arm Cortex-M0+, M4 and M33, and RISC-V) and a PC. On the microcontrollers: 6.9 to 8.1 KB with key-value only, 14.5 to 17.1 KB for the sensor build and 37.8 to 44.6 KB for the gateway build with SQL
RAM 232 bytes plus 16 per flash sector, 8 per key slot, 44 per series and one record buffer: 672 to 1,048 bytes on the demo devices. Stack of up to 1,376 bytes on a sensor and about 4.3 KB for SQL on the gateway
Tests 104,942 functional checks; 10,000 power cuts in every standard run and 400,000 in a long run; 28 million fuzzed inputs; runs under AddressSanitizer, UndefinedBehaviorSanitizer and valgrind. All suites pass on the final code, and the last 10 million fuzzed inputs ran clean
Review Seven defects found and fixed, all on the gateway’s input paths. None could lose data on a device
Speed on a PC Against SQLite with one million rows: 1.6 to 1.9 times faster on grouping and 2.6 to 3.9 times slower on filters and sorts, with 41% more storage per row
Flash wear One reading a second into 64 KB of 10,000-cycle flash would last about 9 months; storing 10-second summaries stretches that to about 4.5 years (computed)
Readiness TRL 4, “technology validated in lab”. Not yet run on a microcontroller

The Demo: One Engine, Three Industries

Three simulated devices run the same unchanged engine. Only the set-up differs: flash layout, memory, data layout, the rule the device applies by itself, and what it sends over which link.

Device Decided on the device Link Bytes sent Every record, bytes As JSON, bytes
Machine sensor Overheat alarm and fan, three times, once while Wi-Fi was down Wi-Fi, out for 15 minutes; summaries-only gateway 2,533 96,133 190,800
Cold-chain logger A 51-minute temperature excursion, recorded far from coverage Mobile, at depots only 6,810 179,610 328,374
Soil sensor Irrigation valve, opened four times in 30 days Radio, one message a day of at most 51 bytes 1,140 86,400 (computed) 207,360

Open Source on GitHub: Releases 0.1 and 0.2

Release 0.1.0-alpha went public on 2 October 2026 and 0.2.0-alpha on 5 October 2026, at github.com/AltSql/altsql under the Apache License 2.0, with the notice “Copyright 2026 AltSql.com”. Release 0.2.0-alpha leaves AltSql Core unchanged at 0.1.0-alpha and moves AltSql DB to 0.2.0-alpha. Every row write now goes through one path, a batch that arrives ahead of a lost one can no longer skip records, and a command-line shell comes with it. The figures below were measured on the released code on 5 October 2026.

Area Result on release 0.2.0-alpha
Interface test 4 seeds of 25,000 random steps (100,000 in all), each run twice, once as SQL text and once as direct calls. After every step the two files gave the same answer and the same refusal, code for code, and the 2,996 whole-table comparisons all matched. At the end the files were identical byte for byte
Sync in order 8 runs of 150 rounds, with 4 devices each sending up to 4 batches ahead over a link that lost 507 batches, delivered 527 twice and reordered 9,312. The gateway refused 3,529 batches as gaps and applied every record exactly once. On the same runs the 0.1 way lost 16,109 records
Older tests The six 0.1 test suites print the same logs as before, apart from the version line, the crash matrix of 3,354 power cuts included. Against SQLite 3.53.4, 103,612 SELECTs and 28,507 writes gave 850,354 rows compared and none different
Other checks AddressSanitizer and UBSan on 7 suites, valgrind on 5 suites with 0 errors, strict builds with gcc 13.3 and clang 18.1, and 10 minutes of fuzzing (745,022 inputs, 0 failures) all passed
Shells and binaries Two shells carry records from a device to a gateway on a PC: altsql for a device’s file and altsql-db for a gateway’s. The end-to-end shell test passed on the built shells and on the static Linux x86-64 binaries, an archive of 814,198 bytes. A browser demo shows twelve devices syncing into one AltSql DB file
Code size AltSql DB with both file ports is 100,383 bytes of code (96,821 without them) and AltSql Core’s gateway build is 68,180. Together they come to 168,563 bytes, 17.2% of the 982,281 bytes of SQLite 3.53.4 (computed)

Where It Stands

Our own assessment, gaps included. The engine and the database work and are well tested in simulation. Everything runs on a PC in simulation, and nothing has run on real flash, radios, batteries, a microcontroller or a gateway yet. Sync has no authentication or encryption yet, firmware with several threads needs locking hooks, and every test so far was written by the people who wrote the code. The code and the core tests are now public, so outsiders can read and rerun them. With several gateways, one that lags can miss a delete; the Beta fixes this by tracking each gateway. AltSql DB has no statement savepoints and no secondary indexes yet (both are planned for 0.3), and its speed figures come from a shared cloud machine that needs a quiet one to repeat them. We estimate the Alpha is about a quarter of the way to a first production release.

The Beta: About 16 Weeks

The Beta takes the same engine to real hardware, as set out in Sections 10 to 12 of the Alpha Report:

  • Five microcontroller families on five boards costing $4 to $47 each: Arm Cortex-M0+, M4 and M33, RISC-V, and Xtensa on the ESP32-S3.

  • Real power cuts. A rig cuts each board’s power 10,000 times while it writes, and the database is checked against the same model as in simulation.

  • Three industry devices on real hardware, with real sensors and radios (Wi-Fi and LoRaWAN), reporting for seven days to one gateway that runs AltSql DB.

  • The first piece of Studio, a paid add-on. Each device is built from a short set-up file, and the time to set up a new one is recorded.

It needs two to three engineers and well under $1,000 of hardware. The exit criteria are measurable: every test suite passing on all five families, at least 10,000 real cuts per board with no acknowledged write lost, and every size and speed figure measured again on the chips.

The Advanced Beta: The Learned Query Optimizer

After the Beta, AltSql.com plans the Learned Query Optimizer (LQO), an optional layer and a paid add-on, set out in the Advanced Beta concept paper (v0.1). It lets the engine take its own situation into account (battery, link, storage, events and the data itself) in two modes:

Optimize
The same answer, reached more cheaply: from summaries instead of raw rows, sent in a better order, timed to the battery and the link.
Adapt
A different answer, only where the application allows it, and always labeled: an average from a sample with its error bound, a forecast marked as a forecast.

Five Decisions the LQO Makes

Decision Alpha today With the LQO
Where an answer comes from The raw rows of the series a query names Raw rows, summaries, a sample or a model, chosen by cost and allowed error
What to keep The oldest rows roll over first, whatever they hold Detail kept around events that matter; routine periods kept as summaries
What to send, and when Records go in order whenever the link allows The most useful records first, timed to predicted coverage
How often to measure A fixed interval set by the application A suggested interval from recent change, battery and storage
When to raise an alert Fixed thresholds in application code A learned normal range per device, with the fixed threshold kept as a hard limit

The Application Stays in Control

Nothing adapts unless the application allows it, in the set-up file or in the query itself. Each series gets a contract. A series declared exact is never sampled, predicted or dropped, so a cold-chain excursion record stays exact as compliance evidence. Every answer the LQO touches carries a label (exact, exact from summaries, approximate, predicted or reduced), and every decision it takes is stored as a record that anyone can check later.

What We Measured

Two early tests. On the Alpha engine with a million readings, an hourly-average query ran 38 times faster from summaries kept in their own storage area (a second database stood in for that area), and a per-machine average 48 times faster, with the same results up to rounding. Summaries kept in the same log gained only about 2 times, so tiered storage is the first engineering step. On the device side, six typical small models came to 684 bytes of code on a Cortex-M4F. We budget 3 to 5 KB for the whole device side of the LQO, an estimate.

In the Verticals

Vertical What the LQO would do (benefits still to be tested)
Industrial machine monitoring Learn each machine’s normal temperature for its load; keep full detail around incidents and summaries otherwise; send alarms first after an outage
Cold chain and logistics Warn the driver minutes before an excursion; upload before the truck enters a dead zone; keep the compliance log exact
Agriculture Learn each field’s drying curve; measure more often after rain; choose what the one daily radio message carries
Next verticals The same pattern carries over: a meter learns its household’s load and sends exceptions first, a pump learns its normal vibration

Plan and Business Value

Four phases follow the Beta: foundations (tiered storage, exact answers from summaries, sync from gateway to device), then learning on the gateway, then adaptation on the device, then learning across fleets with model packs per industry. The first three take roughly 9 to 13 months (estimate). The LQO is designed to add no code when it is compiled out. Its first phase changes storage and sync, so it is planned to land before the v1.0 format freeze.

For the business it adds a paid add-on per product line and a new kind of library asset: model packs per industry, trained on fleet data with the customer’s consent. It also puts AltSql.com inside the AI stack on devices, which is what an AI infrastructure buyer would pay for (Section 15). Research is a warning as much as a guide. A 2024 study found that current learned optimizers “do not systematically perform better than PostgreSQL”. So the LQO steers the exact mechanism the engine already has, keeps it as the fallback and publishes its measured gains and failure rates.

Customization and Support: Where the Money Is

The Name of the Game

Every customer’s device is different, and every industry adds its own rules. Most vendors treat that variety as a cost. They ship one product with a manual and leave the fitting to the customer, who spends months on it and then maintains the result alone. AltSql.com is built around that work. The code is free to try. Customization and support bring the first revenue, and the add-ons that grow out of that work follow. The engine and the platform exist to make both services fast.

OUR POSITION

What other companies see as a hassle, we see as the opportunity: high-margin, customized solutions, delivered quickly through a flexible platform.

The Set-Up Decides the Outcome

The Alpha’s own numbers show how much the set-up matters. The engine source is the same in every row:

Set-up choice Result in the Alpha
Machine sensor storing every reading in 64 KB of 10,000-cycle flash Flash worn out in about 9 months (computed)
The same sensor storing 10-second summaries instead About 4.5 years (computed)
The same sensor on 100,000-cycle external NOR flash About 7 years (computed)
Machine sensor sending every record upstream 96,133 bytes an hour
The same sensor sending summaries and fan state only 2,533 bytes an hour
Cold-chain logger with 512 KB of flash in eight 64 KB sectors 920 bytes of engine RAM
Key-value layer only, or the full gateway build (Cortex-M4) 7.2 KB, or 38.1 KB of code

A wrong set-up can wear out a product in the field within a year. A right one costs nothing extra in hardware. Getting it right for each device takes knowledge of flash parts, radios and industry rules, plus tests on the real board. Customers pay for exactly that.

A Platform Built for Customization

  • Build switches. Layers a device does not use are left out entirely, from a 7 KB key-value build to a 38 KB gateway build.

  • Set-up in place of new code. From the Beta, flash layout, memory, data layouts, rules, retention and what to send become settings in a short set-up file that Studio, a paid add-on, turns into a build. In the Alpha each set-up is a few lines of C, and the three demo devices already share every line of engine code.

  • The library, a paid add-on, from the Beta on. Each new device starts from the nearest proven chip target and industry profile, so most of a project is reuse.

  • Lab, from the Beta on. Power-cut rigs and endurance runs on real boards turn each build into evidence the customer can show an auditor. The results stay proprietary.

  • AI-assisted porting under one standard of proof. New ports and drivers are written quickly with AI-assisted tools, and each must pass the same Lab suite before it ships.

The working target is a new device set up and proven in days, where teams now often spend months. The Beta records the time it takes to set up each device, which gives the first real measure.

Why the Margins Can Be High

An illustrative project, to be tested with design partners: a cold-chain company wants the engine on its own logger, with a different flash part and a mobile modem.

Item Illustrative figure
Nearest match The Beta’s cold-chain profile and ESP32-S3 target, already in the library
New work A driver for the flash part, message sizes for the modem, the customer’s record-keeping rules, Lab runs on the customer’s board and a test report
Effort About 3 engineer-weeks, plus rig time
Direct cost About $13,000: $15,000 per engineer-month fully loaded, plus $2,000 of Lab time
Project price $40,000
Gross margin About 67% on the project
What follows An add-on license for the product line, a support contract for the device’s life and, where the customer wants it, Fleet

Margins can stay high as the business grows. Prices follow the value to the customer, which is months of engineering saved and a decade of support, while our cost follows the effort, which shrinks as the library grows. The recurring lines that follow a project, add-on licenses and support, cost little to serve once a build is proven.

Support for the Life of the Product

Devices stay in the field for ten years or more. In that time flash parts reach end of life and need new drivers, chip vendors release new SDKs, industry rules change, and security fixes have to reach every product line. Under the Cyber Resilience Act a maker must also handle vulnerabilities for the support period it states at the time of sale. Each of these is a reason to keep paying the supplier who knows the build. Support and long-term maintenance contracts turn one customization into a relationship that lasts as long as the product. The code is free to use, so what the customer pays for is the work: the fixes, the drivers and the proof that a build still passes on the real board.

Guarding Against the Services Trap

Customization can drift into low-margin consulting. Four rules guard against it:

  • Every project reuses the library and adds something back to it. Work that leaves nothing reusable is priced higher or declined.

  • Standard packages with fixed prices, such as a new flash part or a new industry pack, cover most requests.

  • The measures below go to the board every quarter, so drift toward consulting shows early.

  • Contracts leave AltSql.com the rights to the targets and profiles it builds, so they can join the library. Exclusive work costs more.

How We Will Measure It

Measure What it shows Target by month 24
Time to a proven build From a set-up file to a build that passes Lab on the customer’s board, for a chip family already in the library Days; two weeks at most
Library reuse The share of each project’s work that came from existing targets and profiles Above 70%
Project gross margin Project price minus engineering and Lab cost 60% or more
Support renewal Support contracts renewed each year 90% or more
Recurring share of revenue Add-on licenses, support and Fleet as a share of all revenue About half, and rising

All five are targets. The Beta gives the first real figure for the time to a build, and the first design partners give the rest.

Market Opportunity

Market Size: Tens of Billions, Growing About 40% a Year

Tens of billions
of dollars: our estimate of today’s embedded and edge data market
About 40% a year
our estimate of its growth, led by embedded AI and autonomous machines

We define the market as the data layer inside devices and at the edge: on-device databases, edge data management, device-to-cloud sync, and the engineering and support services around them. By our estimate it is worth tens of billions of dollars today and grows about 40% a year as computing moves into machines. Both figures are our own. AltSql.com sells into it per product line (add-on licenses), per project (customization), per year (support) and per device (Fleet), on top of free open code.

Where the Growth Comes From: Each Wave Needs Its Own Fit

Wave What the devices do with data What has to be customized
Embedded AI Models run on the device and keep context, features, results and logs locally Fast local reads and writes, a small footprint, memory fixed per chip
Robotics Industrial, warehouse and service robots log sensor streams, state and events without pause Time-series layouts per robot, crash safety, queries on the robot and the site gateway
Smart things Appliances, meters, wearables and building systems store settings and readings The smallest builds for cheap chips; flash layouts per part
Drones Flight logs, mission data and image metadata stay on board, often with no connection Power-loss safety, compact storage, sync set for after landing
Driverless vehicles Vehicles record and filter large volumes of sensor and event data on board Certifiable builds, fast filtering, a clean path to the cloud
Industrial and medical devices Machines and instruments keep audit trails and calibration data for years Audit records per industry, long-term support, certification

These devices share one need, a dependable place to keep and query data on the device, and differ in almost everything else. That is the gap AltSql.com fills, and even a thin slice of this market supports every outcome later in this section.

What Embedded Buyers Already Pay

Two public price lists show what device makers pay for embedded data software and for the support around it:

Product or service Price
SEGGER emFile embedded file system: single-product license with source code From $3,080 to $8,780 per product by edition, with 6 months of support; then 20% of list price a year
SQLite Annual Maintenance Subscription $1,500 a year
SQLite Technical Support Agreement $8,000 to $85,000 a year
SQLite Consortium Membership $150,000 a year
SQLite License (warranty of title) $6,000 one time
SQLite extensions for encryption and compression (SEE, CEROD, ZIPVFS) $2,000 to $4,000 one time each

SEGGER licenses per product, product family, CPU architecture or company, with source code, six months of support and paid yearly extensions. SQLite is public domain, yet companies pay up to $150,000 a year for membership and support around it, and SQLite’s developers will run its test harness on a customer’s hardware at a custom price. AltSql.com follows the same pattern, with free code and paid extensions, support and fitting. It adds what these lists lack: fitting to the customer’s hardware as a standard, fixed-price project, and fleet services.

Who Pays

Buyer group What they need What they pay for
Device makers (industrial, energy, medical, automotive, consumer) A data layer fitted to their hardware that survives power cuts and passes audits Add-on licenses, customization projects, support, Fleet, certified builds
Design houses and system integrators Custom devices for many clients, each one different Add-on licenses for many product lines; also a sales channel
Chip and module vendors Data software ready for their parts, to win designs Validated targets for their SDKs; silicon-vendor add-on licenses
Operators of device fleets (utilities, logistics, farms) Complete, timely data from devices they did not build Fleet and support, directly or through the maker

What Has to Be True for a Venture Outcome

Illustrative paths to $10 million in annual revenue; a real business would blend them.

Path Illustrative arithmetic What has to be true
Add-ons and support 400 product lines × $25,000 a year for add-on license and support = $10M The open code becomes a normal way for device makers to add a data layer, customers buy add-ons on top of it, and support renews for the product’s life
Customization 100 projects a year × $100,000 = $10M Customers pay for new targets, industry packs and certified builds, and each project adds to the library
Fleet 10 million devices × $1 a year = $10M Fleet becomes the way customers run devices on the AltSql engine in the field, and per-device pricing holds

Outcome Scenarios

Scenario What it looks like Annual revenue Timing
First customers Design partners on the Beta; first paid customization projects Under $0.5M, mostly projects Year 1
Early business v1.0 with the first add-on licenses per product line; support contracts; 30+ targets in the library $0.5M to $1.5M, projects included Years 1 to 2
Strong niche The usual customized data layer in a few verticals; Fleet in use; 50+ targets $2M to $5M Years 2 to 4
Venture outcome A standard way device makers add a data layer; model packs per industry; strategic interest $10M+ Year 5 onward

Paid projects and support bring revenue from the first year, and add-on licenses follow as the add-ons ship. The seed plan aims for the top of the second row by month 24, with $0.5 to 1 million of it recurring, which we expect to support a Series A. An early sale at the end of year one would cut this path short; Section 15 describes that scenario.

Verticals

The Alpha demo covers three industries, and they are where selling starts. The same engine fits many more: any device that keeps data, decides locally and talks over a limited link. The verticals below include, and are not limited to, the ones we see next.

The First Three

Vertical Why customization matters there What the AltSql engine fits First pack
Industrial machine monitoring Many machine types and sensors; alarms must work when the plant network fails Fast readings, local alarms, summaries upstream Machine monitoring
Cold chain and logistics Long gaps in coverage; excursion records kept as compliance evidence Whole-trip logs, excursion rules, sync at depots Cold-chain logger
Agriculture and environmental sensing Small batteries and radios; months in the field Small builds, local control, tiny daily messages Field sensor

Next Verticals

Vertical Devices What gets customized Earliest start
Energy and utilities Smart meters, grid sensors, solar inverters, home batteries Interval data kept for billing, tamper records, low-power radio links Years 1 to 2
Smart buildings HVAC controllers, occupancy and air-quality sensors, access control Local control when the building network fails; long retention of summaries Years 1 to 2
Water and infrastructure Leak detectors, pump stations, bridge and tunnel sensors Battery life over years, alarms on the device, sparse radio links Years 1 to 2
Retail and vending Refrigerated cases, vending machines, smart shelves Cold-chain rules reused; sales and stock logs; sync over shop Wi-Fi Years 1 to 2
Vehicles and fleet telematics Trucks, EV chargers, rail and marine assets Event logs kept through coverage gaps, high write rates, audit trails Year 2
Drones and robotics Flight logs, mission data, robot state Power-loss safety at high write rates; sync after landing or docking Year 2
Healthcare and wearables Patient monitors, lab instruments, wearables Audit trails, long-term support, certified builds Year 2 onward, with certification
Consumer devices and smart home Appliances, thermostats, locks The smallest builds on the cheapest chips, sold through chip vendors and design houses Year 2 onward

How a New Vertical Enters the Library

STEP 1
A design partner brings a device and its industry rules
STEP 2
A customization project builds the profile: data layouts, rules, links
STEP 3
Lab proves it on the partner’s hardware
STEP 4
The profile joins the library as an industry pack
STEP 5
Later, a learned model pack for the vertical

Each new vertical costs less than the one before, because chip targets and much of each profile carry over. Cold-chain rules carry into retail refrigeration, and field-sensor builds carry into water and infrastructure.

What an Industry Pack Contains

A pack is what a vertical leaves in the library. The demo’s cold-chain logger shows the parts:

Part of the pack In the cold-chain logger
Data layouts Temperature readings with the door state, 15-minute summaries and excursion records
Rules on the device Above 8 °C for 15 minutes: record an excursion. Short warm spells while the door is open do not count
Retention The whole trip stays on the logger: 48 hours at one reading every 30 seconds fits in 512 KB of flash
Link settings Summaries and excursions over the mobile link in small messages; the full log at the dock
Compliance records Each excursion kept exact, with its start, duration and peak temperature
Test profile The power-cut and endurance runs the pack must pass on each target, and the week-long device run from the Beta
Model pack, later A learned forecast from the LQO that warns the driver minutes before the 15-minute rule would fire

A customer in a new vertical buys the project that builds its pack. The next customer in that vertical starts from the pack and pays for the differences.

Moat and Differentiation

AltSql.com competes on how fast and how well it fits a device, and on staying with the customer for the life of the product. The code is open, so the moat sits outside it. It is made of things that take years to build: a library of proven builds, the evidence behind them, long customer relationships and, later, models learned across fleets.

What Sets AltSql.com Apart

Open code, paid fitting
Teams try the code for free, then buy a standard, priced project that fits it to each chip, sensor and industry
Proof on the real board
From the Beta on, every build passes power-cut and endurance runs in Lab before it ships
One format, sensor to cloud
The same records on the device and on the gateway, with sync built in
An engine that learns
The LQO, a paid add-on, will adapt the engine to the device’s situation, within contracts the application sets

How AltSql.com Differs from the Alternatives

Alternative What it does well What it leaves to the customer What AltSql.com adds
In-house code Fits exactly one product; no license fee Writing, testing and maintaining storage, glue and sync code for every product, for a decade The biggest alternative. AltSql.com adds time saved on every product, a build proven in Lab and a supplier who supports it for a decade
SQLite Trust, full SQL and a huge ecosystem; very thoroughly tested Fitting it on small chips, since it is under 900 KiB with all features; converting device data; building sync Builds from about 7 KB for microcontrollers, the same records on device and gateway, and sync built in
FlashDB, SDK and RTOS stores (ESP-IDF NVS, Zephyr NVS) Tiny and free; FlashDB is proven on STM32 chips; SDK stores come installed Queries, gateway SQL, sync and vendor support. SDK stores are tied to one chip family or operating system One engine across chip families, with SQL on the gateway, sync and support for the product’s life
Commercial embedded storage (SEGGER emFile, Tuxera) Proven file systems, licensed with source code, with strong support The data layer on top: records, queries and sync. SEGGER added SQLite on top of emFile in 2025 for large databases A complete data layer for small devices, customized per product
Commercial database engines (McObject eXtremeDB, ITTIA DB Lite, Raima) Track record, certifications and device-to-server features Fitting a general product to each device A build from about 7 KB, open code to try, customization sold as a fixed-price product, and Lab proof for each build
Edge databases with sync (ObjectBox, Couchbase Lite) Working sync; ObjectBox itself is under 1 MB, as published Fitting into microcontroller-class devices, since they suit phones and Linux-class devices better Builds of about 7 to 45 KB for microcontrollers
Cloud IoT platforms Scale, dashboards and integrations Deciding on the device and working through outages; devices serve as senders Devices that decide for themselves and send only what matters

The fair reading: FlashDB is smaller (about 8.3 KB for key-value and time-series on an STM32F4, as published, against 13.4 KB for the same parts of the AltSql engine on a Cortex-M4) and already proven on chips. SQLite is far more capable and far more tested. Commercial engines such as ITTIA DB Lite and eXtremeDB also span device and server. The case for the AltSql engine rests on doing both jobs in a small build with one format and one sync, with the code free to try, customization sold as a product and its proof from Lab. So far the engine has shown this in simulation only.

Where the Moat Comes From, Strongest First

  1. The validated library. Chip targets and industry profiles, each proven on real boards. Every customer project adds to it, while a newcomer starts from zero, buying boards and running tests target by target.

  2. Proof as an asset. Hardware Lab results for every target and build, certified builds, and the add-ons with their tests stay proprietary, while the core tests are public with the code. Code is cheap to copy, and Lab results gathered over years take years to rebuild.

  3. Relationships that last a decade. Firmware stays in the field for ten years or more, and support contracts, Fleet and the customer’s own processes come to depend on the build.

  4. Learned model packs. After the Advanced Beta, LQO models trained across fleets (with consent) join the library, per industry. Each device in a vertical adds data that a newcomer does not have.

  5. What the company keeps. The add-ons and their code, the Lab results, the library, the AltSql trademark and the direction of the open project, since the company writes the releases. Anyone can copy the open code. A copy has none of these, and a buyer of the company gets all of them (Section 15).

  6. Certification kits for regulated industries: MISRA C compliance, traced tests and safety documentation. They are hard to copy and sticky, and costly enough that early revenue has to fund them.

The code itself is no moat, since AI tools make it cheap to write, and now that it is open anyone can copy it, a large company included. Being small is no moat either (FlashDB is already tiny), and any feature list can be matched in a release or two.

Why the Opening Is There

The device tier is fragmented, and Microsoft and MongoDB have both stepped back from it. Free engines usually leave the fitting and the support to the customer, and commercial engines sell a general product that the customer still has to fit. AltSql.com offers free code to try and does the fitting quickly and repeatedly, from a library that grows with each device, and it stays with the customer for the life of the product. The window will not stay open forever: the largest AI and chip companies are already buying their way to the edge (Section 15).

Where AltSql.com Won’t Compete

  • Analytics over large datasets (DuckDB’s lane) and hosted cloud databases.

  • Full SQLite compatibility, a race no newcomer wins, and mobile app databases.

  • Custom engineering that leaves nothing reusable behind.

Business Model

Open Core by Design

AltSql.com publishes its two products, AltSql Core (the engine) and AltSql DB (the database), as open source under the Apache License 2.0, with the notice “Copyright 2026 AltSql.com”, at github.com/AltSql/altsql. It sells what sits on top: proprietary versions, premium add-ons and modules under commercial licenses, plus customization projects, support and long-term maintenance. Four reasons for this model:

  • Free code gets tried. A proprietary engine from an unknown company has little chance of reaching the market, because embedded teams try free code before they buy anything. Open source lowers the cost of trying.

  • Revenue comes from what sits on top. The free code does not fit a chip, pass an audit or stay current for ten years by itself. Add-ons, customization, support and maintenance do, and customers pay for them.

  • The code can be inspected. Anyone can read the code and run the core tests, so the claims in this proposal can be checked.

  • Apache 2.0 suits firmware. Firmware makers avoid copyleft, and this license lets them build the code into their own products.

The cost of the model is fork risk. A large company can take the open code and compete with its authors. The answer is what a copy lacks: the add-ons, the Lab results, the library, the trademark and the people and customers behind them (Section 9).

What Is Free and What Is Paid

Part Free, under Apache 2.0 Paid, under commercial licenses or contracts
Engine and database AltSql Core and AltSql DB, with key-value, time series, SQL and sync, the shells, the demo and the core tests Proprietary versions, and premium add-ons and modules built on top of the open code
Platform The build switches in the code Studio, Fleet, the library of validated targets and the LQO, as paid add-ons or services
Proof The core test suites, public with the code Hardware Lab results, certified builds, and the tests that go with each add-on
Fitting and support The code as released Customization projects, support and long-term maintenance for the product’s life
Other prototype modules Not released: all rights reserved Candidates for premium add-ons; nothing is promised

Seven more modules exist as prototypes: AltSql Ask, Vector, Wave, Mesh, Realtime and Instant, and AltSql Private, which is on hold. They stay all rights reserved. Each is a candidate for a premium add-on, and nothing is promised.

Revenue Lines

Offer What the customer gets Working price, to test Type
Add-on license A commercial license for a premium add-on, module or proprietary version on top of the open code, such as Studio builds and updates, for one product line $5,000 to $20,000 a year (estimate) Recurring
Customization project A new chip, flash part, sensor profile or industry pack, built and proven in Lab on the customer’s hardware $20,000 to $150,000 a project Project
Support and long-term maintenance Response times, security fixes, long-term-support builds and driver updates for the product’s life $10,000 to $60,000 a year Recurring
AltSql Fleet A paid add-on: deployment, set-up updates, sync and storage health across devices in the field About $1 per device a year; free for pilots Recurring
Certified build A build with safety documentation and traced tests for a regulated product $25,000+ per product, plus annual support Project, then recurring
LQO add-on and model packs The Learned Query Optimizer as a paid add-on for a product line, and models per industry, after the Advanced Beta Priced with the first customers Recurring
Company-wide and silicon-vendor licenses Add-ons across all the product lines of a large customer; add-ons and support for chip vendors that ship the open code with their SDKs Negotiated Recurring

SQLite’s support prices (Section 7) anchor our support line. Our yearly add-on license sits above SEGGER’s one-time file-system license because it includes Studio builds and updates, and design partners will test that price. A customization project usually opens the account, and add-on licenses, support and Fleet keep it. The open code itself carries no license fee, for device makers and chip vendors alike.

The Decision Taken: Apache License 2.0

Earlier drafts kept three open-source options on the table (a community edition with only the key-value core, a dual license with copyleft, and source-available evaluation) and left the choice for about month 12. The company has taken the decision, ahead of the Beta:

Decision What it means
What is open AltSql Core (the engine) and AltSql DB (the database), whole, with the shells, the demo and the core tests
License Apache License 2.0, with the notice “Copyright 2026 AltSql.com”
Where and when github.com/AltSql/altsql: release 0.1.0-alpha on 2 October 2026 and 0.2.0-alpha on 5 October 2026
What is not open Proprietary versions, premium add-ons and modules, Lab results and certified builds, and the seven prototype modules, which stay all rights reserved

The three options are set aside. A community edition would be a second product to maintain, a copyleft license deters some evaluators, and source-available code draws less from the community because it does not meet the usual definition of open source. Opening code is also hard to take back: Redis and Elastic both drew heavy criticism, and forks, when they moved away from open-source licenses. So the line between free and paid is drawn now, with paid work on top of the open code in separate add-ons and modules.

Owning the IP Cleanly

  • All copyright in the company’s own code held by the company, with the notice “Copyright 2026 AltSql.com” on the open code.

  • A contributor agreement for outside contributions to the open code is under consideration, so the company could keep licensing its commercial versions.

  • Add-ons and modules built on top of the open code and licensed separately, so the license of every part is clear.

  • Customer contracts that leave the company the rights to the targets and profiles it builds, so they can join the library. Exclusive work is priced higher.

  • The AltSql trademark held by the company. The Apache License gives no right to use the name, so the name stays with the company.

  • Records of human design and review for AI-assisted code, since the law on copyright in AI-generated code is still unsettled.

  • A review with patent counsel of the LQO’s tiered storage and its decisions based on the device’s situation.

Go-to-Market

From First Project to Lasting Account

STEP 1
Evaluate: the free open code on a dev board
STEP 2
Customize: a paid project fits it to the product and proves it in Lab
STEP 3
Add on: an add-on license where the product needs one
STEP 4
Support: a contract for the life of the product
STEP 5
Expand: more product lines, Fleet, certified builds, the LQO

The first sale is usually a customization project. Every product line a customer adds after it brings another add-on license and another support contract, and much of its build already exists.

Channels

  • Developers, through GitHub, who try the free code first.

  • Device makers, directly, through a design-partner program in each vertical.

  • Design houses and system integrators, who build custom devices for many clients, each of whom brings new product lines.

  • Chip and module vendors, with validated targets in their SDKs and silicon-vendor add-on licenses.

  • Industry specialists, such as cold-chain or metering companies, who embed the open code or resell the add-ons.

Design Partners

In each of the first three verticals, three to five device makers get customized builds at a reduced price and a say in the roadmap, in return for feedback, field data (with consent) and case studies. More join as the next verticals open, for 10 to 20 in all by month 24.

How Revenue Arrives

Embedded products are designed in long before they ship, so revenue arrives in steps. Working assumptions:

Step Typical duration (assumption) Revenue
Evaluation Weeks None: the open code is free to try
Customization project 1 to 3 months The project fee
Product development 6 to 18 months, until the product ships An add-on license, where used, from the start of development, and a support contract
Production and field life Ten years or more Add-on license and support renewals; Fleet per device
New product lines Every year or two per customer Another add-on license, often after a smaller project

Add-on licenses start paying during development, well before devices ship. Per-device revenue from Fleet builds more slowly, and the month-24 targets do not depend on it.

Roadmap and Milestones

Timing follows the Alpha Report: about 16 weeks for the Beta, then 6 to 9 months to v1.0.

Stage Timing What ships Proof points
Alpha (done) September and October 2026 The engine in one C file; the gateway database AltSql DB; 400,000 simulated power cuts; a three-industry demo in simulation; open source on GitHub, with release 0.1.0-alpha on 2 October and 0.2.0-alpha on 5 October 2026 TRL 4; code sizes for four microcontroller families; the 0.2 interface and sync tests
Beta Months 0 to 4 Real boards from five microcontroller families, with flash drivers and locking hooks; AltSql DB on a Linux gateway; a power-cut rig; three industry devices; set-up files and a generator; format and API frozen for Beta users 10,000 real power cuts per board; a 7-day run; TRL 5
v1.0 release and first add-ons Months 4 to 13 Format and API frozen for production; hardened drivers; sync security; Studio on the command line as the first paid add-on; long-term support; three industry packs First add-on licenses, projects and support contracts
LQO, phases 1 to 3 Months 4 to 17 Tiered storage and exact answers from summaries; learning on the gateway; adaptation on the device. The LQO is a paid add-on Phase targets met on the three industry devices
Scale Months 12 to 24 Fleet generally available; Studio on the web; 30+ validated targets; certified-build and model-pack pilots Evidence for a Series A

Milestones: Two Paths from Month 12

The plan makes AltSql.com ready for an early sale by month 12 (Section 15). If no offer beats the plan, the same work carries on to a Series A at about month 24. All milestones are targets:

By month 12: ready for an early exit By month 24: ready for a Series A
Engine The open code released on GitHub throughout; the Beta done by month 4 (five microcontroller families, 10,000 real power cuts per board, a 7-day run); v1.0 at or near release v1.0 released, with a stable format, a long-term-support policy and an external security review
LQO Phase 1 done and phase 2 under way: exact answers from summaries on real devices; first models trained on the gateway Phases 1 to 3 done, with measured gains on the three industry devices
Library About 10 validated targets and the first three industry packs 30 or more validated targets and five industry packs, with Lab results for each
Customers Design partners in the first three verticals; the first paid projects and add-on licenses 10 to 20 design partners, at least five shipping the AltSql engine; a certified-build pilot
Revenue Under $0.5 million, mostly from projects $0.5 to 1 million a year recurring, from add-on licenses, support and Fleet, plus projects
Company About 19 people; the add-ons, the Lab results and the copyright in the open code held by the company; trademarks filed; a patent review done The evidence for a Series A, or for a later sale on the strength of revenue

Team and Hiring Plan

The plan needs the team below, described as roles: what each role does, what it needs and when it starts.

How the Work Is Organized

Group Mission
Engine AltSql Core and AltSql DB, both open source: storage and crash safety, key-value, time-series, SQL, sync, the chip ports and the public releases
Platform Studio, Lab automation and Fleet: the paid add-ons and tools that make customization fast and support cheap to deliver
Customer engineering Customization projects, industry packs and support contracts. This is the revenue engine, run as a team of its own
Advanced Beta The Learned Query Optimizer, and the gateway pipeline that trains its models
Commercial Sales, partnerships, design partners, evaluation kits and technical marketing

Roles and Requirements

Role What the role does What it needs Count Start
CEO Strategy, sales, partnerships and fundraising A commercial leader from embedded software, developer tools or industrial IoT who has sold to device makers 1 From the start
CTO Architecture of the engine and the platform; technical decisions and code review Deep embedded-systems experience; has led a small engineering team 1 From the start
Storage-engine lead On-flash format, crash safety and correctness; reviews all core code Has shipped a storage engine or a flash file system 1 Months 1 to 2
Embedded engineers Chip ports, flash drivers, board validation, power-cut rigs C on microcontrollers; flash memory, RTOS and low-power work 4 Months 1 to 12
Test and Lab engineer Lab automation, test suites, nightly fuzzing Hardware-in-the-loop testing and test automation 1 Month 2
Solutions engineers Scope and run customization projects; build industry packs An embedded background and ease with customers 2 Months 4 to 10
Platform engineers Studio: set-up files, the generator, the build pipeline, reports Build systems, code generation, developer tools 2 Months 4 to 10
Technical marketing Documentation, evaluation kits, examples per board, published core test results An embedded developer who writes well 1 From month 4
Machine learning engineer The LQO: models, contracts, guardrails Machine learning plus embedded C; small models on constrained hardware 1 Month 7
Data engineer The gateway pipeline that trains and checks the LQO’s models Data pipelines and time-series data 1 Month 9
Support engineer Support contracts, long-term-support builds, customer issues in the field Embedded debugging; support processes and service levels 1 From month 12
Sales and partnerships Chip vendors, design houses, integrators and industry specialists Sales in the embedded ecosystem 1 From month 9
Fleet and sync engineers Deployment, set-up updates, the sync service and its security Distributed systems, device management, applied cryptography 2 Months 6 and 12
Advisors Industrial IoT, cold chain and energy; safety certification; embedded software licensing Senior practitioners in each field 3 to 4 Before v1.0

The plan reaches about 19 people by month 12, 16 of them in engineering roles, and holds that size to month 24. At a fully loaded $15,000 a month, the engineering roles come to about 280 engineer-months, which is the 60% engineering line in Section 14. The Beta needs only two to three people. Hiring follows the roadmap: the engine and Lab first, then customer engineering and the platform, then Fleet and the LQO. So by month 12 the team a buyer would take on is complete. Headcounts and timing are illustrative and will be confirmed with the board.

Funding Request and Use of Funds

Term Proposal
Round Seed
Amount $7 million
Instrument More likely a priced equity round (preferred shares) than a SAFE, with the valuation to be agreed with the lead investor
Runway About 24 months
Main goals By month 12, a company ready for an early sale: the Beta done, v1.0 at or near release and the LQO’s first results on real devices. By month 24, 30+ validated targets and five industry packs, 10 to 20 design partners and $0.5 to 1 million in annual recurring revenue

Use of Funds

The working shares, applied to the $7 million round:

Area Share Amount What it pays for
Engineering 60% $4,200,000 The engineering roles in Section 13: the engine, the platform, customer engineering and the LQO
Lab, quality and security 10% $700,000 Boards for every target, power-cut rigs, endurance runs, nightly fuzzing, external security reviews
Go-to-market 15% $1,050,000 The commercial roles in Section 13, evaluation kits, trade fairs, design-partner and channel programs
Legal, IP and operations 7% $490,000 Incorporation, license and customer contracts, the open-source license and contributor agreement, trademarks, patent review, accounting, HR and tools
Contingency 8% $560,000 Buffer for slips
Total 100% $7,000,000

What the Round Buys

By month 12 the round makes AltSql.com a company worth buying: an open-source engine and database running on real chips, the first LQO results on real devices, design partners in three industries and a complete team, with the add-ons, the Lab results and the trademark in one company. If the company stays independent, the same money carries it to month 24, with a v1.0 and its first commercial add-ons, a library of 30 or more targets, recurring revenue from add-on licenses, support and Fleet, and learning features measured on real devices. That is the evidence we expect a Series A investor to look for.

Exit Landscape

Two paths lead to an exit: an early sale by the end of year one, most likely to an AI infrastructure company, or a Series A followed by a later sale. The month-12 milestones serve both.

Scenario One: An Early Sale by the End of Year One

This is the early exit we see as most likely. The buyer would be an AI infrastructure company: a maker of the chips, platforms or clouds that AI runs on, with a strategy that reaches into devices. Examples of the type include NVIDIA, Qualcomm, Arm and AMD, and cloud and data platforms such as AWS, Databricks and Snowflake.

Why an AI Infrastructure Company

  • AI is moving into machines. NVIDIA’s chief executive said in March 2026 that “every industrial company will become a robotics company”. Models on devices need a data layer there that survives power cuts and outages and feeds the gateway where models are trained.

  • AltSql.com fits how AI is deployed. The LQO learns on the gateway and decides on the device, the split between training and inference that AI platforms already use.

  • These companies are buying their way to the edge. Qualcomm bought Edge Impulse, a platform for building AI on devices, and agreed to buy Arduino in 2025. NXP paid $307 million for Kinara, a maker of edge AI processors. Nordic Semiconductor bought the technology and 13-person team of Neuton.AI, whose models for microcontrollers are typically under 5 KB.

  • They are buying data infrastructure for AI. Databricks agreed to buy the Postgres company Neon for about $1 billion in 2025, and Snowflake agreed to buy Crunchy Data. IBM completed its purchase of Confluent in March 2026, and Amazon agreed to acquire DuckLabs in August 2026.

  • They buy young teams. Lilac, bought by Databricks in March 2024, and Datavolo, which Snowflake agreed to buy in November 2024, were both founded in 2023.

  • An open-core company is a clear purchase. The buyer gets the team, the commercial add-ons and their code, the trademark and the project’s direction, the installed base and the contracts. The open code stays free under Apache 2.0. When Amazon agreed to buy DuckLabs, the DuckDB project itself stayed with its foundation, while here the project’s direction would pass to the buyer with the company.

What a Buyer Would Get at Month 12

Asset Plan target at month 12
Engine and database Open source and running on five microcontroller families, with 10,000 real power cuts per board and three industry devices through a week-long run, and AltSql DB on a Linux gateway; v1.0 at or near release
LQO A paid add-on: exact answers from summaries measured on real devices; the first models trained on the gateway and sent to devices as records
Library About 10 validated targets and the first three industry packs, each with its Lab results
Customers Design partners in machine monitoring, cold chain and agriculture, with the contracts for the first paid projects, add-on licenses and support
Team About 19 people with storage-engine, embedded, machine-learning and customer-engineering skills
IP and project The commercial add-ons and their code, the Lab results and the library; the copyright in the open code, the trademark and the direction of the open project; trademarks filed; patent review done

All of these are plan targets. Revenue at month 12 would still be small, so the price would rest on the team, the technology and the strategic fit. For the private companies listed below, disclosed prices run from $39 million for Realm in 2019 to about $1 billion for Neon in 2025, and each was older and further along than AltSql.com would be at month 12.

Other Possible Buyers

Buyer type Examples Why they would buy
Microcontroller and module vendors Espressif, STMicroelectronics, NXP, Nordic Semiconductor, Infineon, Renesas A data layer and a library of proven targets make their chips easier to design in. Nordic’s purchase of Neuton.AI shows the pattern
Cloud providers AWS; Microsoft and Google if they return to device data Own the data layer on the devices that feed their clouds. Amazon and DuckLabs is the precedent
Embedded software vendors RTOS, file-system and middleware companies such as Tuxera Add a database and sync to a storage portfolio sold to the same customers
Industrial automation and IoT companies Industrial groups such as Siemens, Bosch or Schneider Electric; IoT platform vendors Own the data layer across their customers’ devices, with deployment built in
Database companies moving to the edge Couchbase and other data-platform vendors Add a microcontroller-class tier below their mobile and edge products

Scenario Two: Series A, Then a Later Sale

If no early offer beats the plan, the round carries the company to month 24 and a Series A, with v1.0 in the field, 30 or more validated targets, 10 to 20 design partners and $0.5 to 1 million in annual recurring revenue. A sale in years three to five would then rest on recurring revenue, an installed base inside firmware and a library that no buyer could rebuild quickly. The same buyers stay in view.

Precedents

Date Buyer Company What it does Price
Mar 2024 Databricks Lilac (founded 2023) Tools for managing the data used to train AI Undisclosed
Nov 2024 Snowflake Datavolo (founded 2023) Data pipelines for enterprise AI; agreed Undisclosed
Feb 2025 NXP Kinara Processors for edge AI; completed October 2025 $307 million
Mar 2025 Qualcomm Edge Impulse A platform for building AI on devices, with 170,000 developers Undisclosed
May 2025 Databricks Neon (founded 2021) Serverless Postgres; AI agents created over 80% of its databases; agreed About $1 billion
Jun 2025 Snowflake Crunchy Data Postgres for enterprises and AI applications; agreed About $250 million, as reported
Jun 2025 Nordic Semiconductor Neuton.AI technology and team Machine-learning models for microcontrollers, typically under 5 KB Undisclosed
Oct 2025 Qualcomm Arduino Boards and software for embedded developers; agreed Undisclosed
Mar 2026 IBM Confluent Real-time data streaming for AI and agents; completed About $11 billion
Aug 2026 Amazon DuckLabs The team behind the DuckDB embedded database; agreed Undisclosed

Earlier deals in embedded data:

  • Realm, a mobile database with sync, bought by MongoDB for $39 million (2019).

  • Datalight, embedded file systems and flash management, bought by Tuxera, terms undisclosed (June 2019).

  • Couchbase, with its mobile and edge database, taken private by Haveli Investments for about $1.5 billion (September 2025).

  • Raima, an embedded database vendor since 1982, sold to Centura, then to Birdstep, then to its own management.

What Makes AltSql.com Worth Buying

Buyers pay for a short list of things: cleanly owned IP, revenue that renews, an installed base inside firmware, and the people who built it. AltSql.com adds the library of proven targets and profiles, which no buyer could rebuild quickly, an engine that learns through the LQO, and support contracts that tie it to customers for years. The open-core model keeps the commercial parts and the direction of the open project inside one company, next to code that anyone can inspect, and the IP rules in Section 10 start on day one.

Follow the Project

Releases, test reports and documentation are published on the AltSql project site and in the AltSql repository on GitHub. AltSql is one of the open-source projects listed on SoftDevStudio.com.

Filed Under: Projects Tagged With: AI infrastructure, enterprise software, startups and funding

Footer

Recent Posts

  • China Turns AI Model Distillation Into Industrial Policy and Weakens the Reach of US Chip Controls
  • AI-Found Software Flaws and the Rush to Patch Them Are Now a Market Risk After a Week of US Outages
  • Ohio Voters Put $17 Billion of Amazon Data Center Spending at Risk as Local Bans Spread
  • US Remote Access Chip Rule and FCC Optics Ban Squeeze Southeast Asia Data Centers and Nvidia China Exposure
  • Microsoft Puts Word, Excel and PowerPoint Inside Copilot and Turns Office Into an AI Front Door
  • OpenAI Cuts GPT-6.2 Astra Prices 20% as Microsoft MAI Code 2 Undercuts Frontier Coding Models
  • Tencent Q3 Shows New AI Products Cost About RMB15 Billion in Operating Profit as Capex Hits 39% of Revenue
  • Anthropic IPO Heads for the Top of Its Range as $900 Billion in Compute Commitments Go Public
  • Nvidia Q3 Revenue Hits $115.8 Billion but the Q4 Margin Guide Drops Three Points as the Board Rules Out Jensen Huang
  • Emboldened Iran and a Weakened Trump Leave US Stocks, Bonds and Oil Pricing a Peace That Has Not Arrived

RSS feed: Market Research Media Market Research Media

  • Four Vendor Surveys on Missed AI Returns Each Find the Problem Their Sponsor Sells a Fix For
  • Wasabi Study Puts Unplanned Infrastructure Spending at $63.4 Billion, With Germany Overspending by 7.1 Billion Euros
  • CSC Survey Finds 88% of Private Capital GPs Spend Up to Half Their Finance Time Checking Administrator Work
  • Lenovo Survey Finds 80% of IT Leaders Tie AI Success to the Digital Workplace and Only 10% Have Redesigned It
  • Claude and ChatGPT Integrations Killed the Headless CMS Market
  • Survey Margin of Error Explained, What Plus or Minus 3 Points Covers and What It Leaves Out
  • Morgan Stanley Pulse Survey Finds Bearish Investor Sentiment Rising to 42 Percent as Inflation Fears Grow
  • A Stronger Week Across the Network, October 4–10, 2026
  • The Tariff Map Is Becoming an Industrial Policy Map—and the U.S. Economy Is Paying the Price
  • PC Shipments Fall 22.4% as Higher Component Costs Price Buyers Out

Media Partners

  • Analysis
  • Technology Conferences
  • OSINT
  • Defense Market
  • Cybersecurity Market
  • Event Calendar
  • Calendarial
  • Opinion
  • 3V
  • Media Presser
  • Exclusive Domains

Copyright © 2026 MarketAnalysis.com | Terms of Service | Privacy Policy | Supplier Disclaimer | The Website Coded and Designed by SoftDev Studio

Media Partners: Technologies | Photography | Referently

We use cookies on our website to give you the most relevant experience by remembering your preferences and repeat visits. By clicking “Accept”, you consent to the use of ALL the cookies.
Do not sell my personal information.
Cookie SettingsAccept
Manage consent

Privacy Overview

This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary
Always Enabled
Necessary cookies are absolutely essential for the website to function properly. These cookies ensure basic functionalities and security features of the website, anonymously.
CookieDurationDescription
cookielawinfo-checkbox-analytics11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional11 monthsThe cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy11 monthsThe cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.
Functional
Functional cookies help to perform certain functionalities like sharing the content of the website on social media platforms, collect feedbacks, and other third-party features.
Performance
Performance cookies are used to understand and analyze the key performance indexes of the website which helps in delivering a better user experience for the visitors.
Analytics
Analytical cookies are used to understand how visitors interact with the website. These cookies help provide information on metrics the number of visitors, bounce rate, traffic source, etc.
Advertisement
Advertisement cookies are used to provide visitors with relevant ads and marketing campaigns. These cookies track visitors across websites and collect information to provide customized ads.
Others
Other uncategorized cookies are those that are being analyzed and have not been classified into a category as yet.
SAVE & ACCEPT