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
-
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.
-
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.
-
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.
-
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.
-
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).
-
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.