Software · Hardware · A.I.

NODESTARK

Your product idea, shipped as real hardware. PCB to cloud, dataset to silicon — one team.

For startups without a hardware team and companies putting machines online: we design the board, write the firmware, get it connected, build the cloud around it — and train the A.I. models that run on the chip itself. Field-proven on a live vending-machine fleet.

PCB→Cloud Full stack
EVA-DTS Protocols
In Field Deployed
AI on MCU Train → deploy
scroll
Hardware PCB · schematic · layout
Firmware ESP32 · NuttX · RISC-V
Connect MQTT · BLE · cellular
Software cloud · web · apps
A.I. train · quantize · deploy

Idea to Production, De-risked

Hardware projects die from scope drift and surprise costs. So we work in stages: each one ends with something concrete in your hands, and you can stop at any stage and keep everything — schematics, sources, models. No lock-in.

01 · scope

Free Scoping

Tell us what you're building. We map it to an architecture, the real risks and a fixed quote — in days, not months.

you get: architecture + fixed quote
02 · prototype

Working Prototype

Schematic, PCB layout, board bring-up and firmware. A board on your desk doing the real thing — not a slide deck.

you get: board + firmware + sources
03 · pilot

Field Pilot

Small batch deployed with real users: cellular or BLE connectivity, MQTT telemetry, cloud dashboard, OTA updates.

you get: live devices + real data
04 · production

Production & Beyond

Design-for-manufacturing, production run, support — and once data flows, A.I. models trained on it, running on the chip.

you get: manufactured product

Everything we produce is yours — schematics, firmware, cloud code, trained models. Start with the free scoping →

The Connected Vending Machine

How we took an entire product line from schematic to a fleet in the field — the same path we run for client projects.

01 · the problem

Vending machines run cash-only and offline. Operators drive routes blind — no sales data, no stock levels, no idea where the machine even is.

02 · what we built

A full ecosystem on the industry-standard MDB bus: cashless payments, a master controller and a cellular + GPS add-on. PCBs, firmware, MQTT telemetry, cloud — all designed and built in-house.

03 · the result

A live fleet in production, reporting sales and location over NB-IoT. The core firmware is open source on GitHub — audit it yourself.

NodeStark board installed in a live vending machine
// in the field

Live deployment

Board wired into a real vending machine's MDB harness — powered up and online.

ESP32-S3 board with SIM7080G cellular modem and GPS
SIM7080G

Cellular + GPS board

ESP32-S3 MDB controller board
ESP32-S3

MDB controller

Green PCB revision with SIM7080G modem
revision

Connectivity board

Batch of manufactured NodeStark boards
production

Manufactured run

Have a fleet of machines of your own to connect? That's exactly what we do →

One Team, the Whole Stack

Most smart-hardware projects need four vendors — a board house, a firmware shop, a software team and an ML engineer. NodeStark is all four. Every capability below is proven in the case study above or in our open-source lab.

🔌

Hardware & Electronics

Schematic capture, multi-layer PCB layout, power design and design-for-manufacturing — from first prototype to production run.

schematic layout DFM
proof: boards in the field →
⚙️

Firmware, RTOS & Emulation

C on ESP-IDF and Apache NuttX — the RTOS behind PX4, Spresense and Xiaomi Vela. Bare-metal, protocol stacks, custom emulators and virtual machines for HIL / CI testing.

esp-idf nuttx RISC-V · VMs
proof: Linux on a $5 chip →
📡

Connectivity & Cloud

Devices online anywhere: NB-IoT / Cat-M with GPS, BLE, Wi-Fi. MQTT telemetry into APIs, device management and operator dashboards.

MQTT NB-IoT / BLE dashboards
proof: fleet reporting live →
🧠

A.I. on the MCU

Neural networks trained on your sensor data, quantized to int8 and running on the ESP32 itself — vision, audio, sensors. Plus on-device KNN vector search.

train → deploy TinyML vision · audio
proof: the full pipeline →

We Train Models for the Microcontroller

Most "edge AI" stops at running someone else's model. We own the whole loop: collect data from your sensors, train a neural network, quantize it to int8 with Espressif's esp-ppq, and ship it as a .espdl binary running on ESP-DL — inference happens on the ESP32-S3 itself, no cloud, no latency, no per-call cost.

01 · train

PyTorch / Keras

Network trained on your real sensor data — behavior learned from examples, not hard-coded rules.

02 · export

ONNX

Framework-neutral export, ready for the Espressif toolchain.

03 · quantize

esp-ppq · int8

Weights compressed to int8 with Espressif's PPQ fork — sized for kilobytes of RAM, not gigabytes.

04 · deploy

ESP-DL on ESP32-S3

The .espdl model lives in flash and runs on Espressif's inference runtime — on the same chip that reads the sensors.

Sensors in, decisions out

Example from our lab: a network that reads temperature, humidity and light, and decides — on the chip — whether to switch the fan, the pump or the lights. The rules are learned from data. Swap the sensors and the dataset, and the same pipeline fits your product — including vision (person and object detection with the ESP32-S3 camera, via ESP-DL) and audio (keyword spotting).

vision keyword spotting predictive maintenance anomaly detection classification
python train_export.py
training sensor_model... done
export → sensor_model.onnx
esp-ppq int8 → sensor_model.espdl (target: esp32s3)
idf.py flash monitor
I (1234) minibrain: T=37.2C U=55% L=640lux -> CMD_FAN_ON
I (3234) minibrain: T=22.1C U=18% L=400lux -> CMD_PUMP_ON
~ #
int8
Quantized weights
0
Cloud calls
flash
Model lives on-chip
ESP-DL
Espressif runtime

Proof You Can Read

Don't take the case study's word for it — read the code we ship. Our product firmware and R&D are open source. Flagship experiment: a RISC-V emulator in pure C that boots a real Linux kernel on an ESP32-S3 — 2.8 MB kernel, 5.0 MB Buildroot rootfs, LittleFS.

ESP32 Board

esp32-running-linux

A custom RISC-V emulator in C for the ESP32-S3 (16 MB flash). Real Linux shell over UART on a microcontroller — boots in under two seconds. → view source on GitHub

idf.py flash monitor
NodeStark RISC-V Emulator v1.0
Mounting LittleFS... OK
Loading kernel 2.8MB... OK
Booting Linux 5.18.7-nodestark
~ #
2.8MB
Kernel image
5.0MB
Root FS
<2s
Boot time
RV32
IMAFDC · ILP32D

START A
PROJECT

Scoping is free: tell us what you're building and you get an architecture, the real risks and a fixed quote — then you decide. Whole stack or just the part you're missing. Everything we produce is yours — no lock-in.

~2min to fill
<24h response
free scoping