The Product · ROSA
ROSA is the software foundation for connected products: security, standardisation, compliance and testing solved beneath your application, so your team builds the product. And for the first time in embedded, you can see all of it.
The model
Atelier is where you work and where you look. Canvas is your product as an explicit model. Foundation is what we maintain, so your team doesn't have to.
ROSA Atelier
The web interface across your whole firmware estate: project status and forecasts, architecture, test results on real hardware, CRA evidence, policies. Management sees where products stand. Engineers do their work. Same records, no separate reporting.
ROSA Canvas
Hardware target, modules, and how they communicate, defined once, in one type-safe configuration. Canvas generates the infrastructure code deterministically. Swap hardware, add variants: your application code doesn't move.
ROSA Foundation
Board support, connectivity, OTA updates, security and dependency management, end-of-line provisioning. Identical across every product you build, and keeping it current is our business, not your team's distraction.
ROSA Atelier
Embedded development is usually a black box between kick-off and release. Atelier opens it, for every role that has to answer for the product.
Management sees every project's progress, forecast and upcoming milestone, derived from the records, not from Friday reports.
Engineers work live with the device, and every interaction can become a regression test on the spot.
For management
Status and forecasts per project, derived from the actual records: test results, findings, milestones, not from hand-written Friday reports.
For architects
Company-wide policies: approved hardware, module allow-list, sanctioned patterns, with per-project adherence visible at a glance.
For engineers
Architecture editing, test authoring, live device consoles, milestone gates: the daily work, in the same interface everyone else looks at.
ROSA Canvas
Canvas is the code generation at the heart of ROSA. You define what your product is. Canvas builds the infrastructure around it, deterministically, not with AI guesswork.
Hardware target, patterns, modules, and the topics that wire them: one editor, one model. The graph on the right updates as you configure it and can never drift from what actually gets generated.
The product model lives in a single type-safe configuration: your hardware target, the modules that make up your application, and how they communicate. Configuration errors are caught at translation time, before your compiler ever sees the code.
Modules never reference each other directly. All communication goes through generated, typed interfaces on named topics: publish/subscribe or request/response, enforced by architecture rather than convention. When hardware changes, the transport changes. The interface does not.
The result is a clean separation of concerns: infrastructure code is generated and never touched by hand. Your team works in exactly two places, the model and the business logic.
You define
Canvas generates
ROSA Foundation
Foundation is what your products stand on. It's the part of firmware that is the same everywhere, breaks everywhere, and eats roadmaps everywhere. We keep it current so your team ships product.
The module library: reviewed like a dependency manifest, with every entry's status and where it's used.
Every Foundation module goes through the same allow-list your architects control: approved, in review, or blocked, with a reason attached. Your team picks from a catalog we keep patched and current, not from a pile of vendored code nobody owns.
Board & Zephyr
Board support and mainline Zephyr integration: a running application in hours, not months. Scalable systems architecture with clean separation of concerns by default.
Connectivity & updates
Matter, Thread, KNX IoT, BLE Mesh, Wi-Fi: standards implemented once, not re-fought per product. OTA updates with MCUboot, A/B partitioning, and rollback out of the box.
Security & production
Dependency and vulnerability management: we keep up so you don't have to. System health, diagnostics, logging. End-of-line testing and provisioning, factory-ready from the start.
Platform maintenance costs are distributed across all ROSA customers instead of carried by your team alone. That's the entire economic point.
Ownership
Generated code is readable, reviewable, and yours, with no runtime dependency on us. You can read it, change it, and ship it without us.
ROSA builds on the standard toolchain your team already knows: devcontainer, CI, upstream Zephyr. Your engineers stay employable, your stack stays portable.
The same model produces the same code, every time. AI tools work exceptionally well on top of ROSA, because the structure is explicit, but your firmware is never a language model's guess.
We start from your existing setup. The first conversation is 45 minutes, no commitment, no sales deck.