Almost five years ago we wrote about being truly full-stack: designing and building mechanics, electronics, firmware, backend, ML models, tools, and mobile and web apps in-house. All of that is still true. But the stack has moved on, and one thing has changed the day-to-day of engineering here more than anything else since: we now build our own AI agents to help build and run Minut.
So here's the 2026 edition.
Minut is the intelligence layer for proactive property management. We help operators of short-term rentals, aparthotels, student housing and multifamily units stay one step ahead of issues like noise, smoke and mold with a small, privacy-safe sensor and a platform that turns insights into actions that improves the guest experience and manager workflows. There are Minut sensors in over 100 countries. (We're still waiting on that Antarctica intro, by the way.)
This is what we use at Minut in 2026:
Working on a truly full-stack team means learning from people with a huge range of skills. We still have both planned and spontaneous technical discussions about architecture, tooling, developer experience and, increasingly, about how far we can push agents to do the boring parts for us.
We're a tight-knit team of engineers working closely with designers, PMs and stakeholders. Engineers are involved early in problem scoping, and we still prefer to release several times a day, automatically, once code review passes.
.png)
Our web dashboard at web.minut.com is a single-page app built with React 19 and TypeScript, bundled with Vite (we retired Gatsby). Server state is handled with TanStack Query on top of fully typed API hooks generated from our OpenAPI schema, so a change to the backend contract shows up as a type error in the frontend before it ever ships. We built our own design system, affectionately called meatball-ui, which is now the first thing you reach for when building UI, styled with styled-components. Tests run on Vitest; Prettier, ESLint and a dead-code check keep things tidy.
The web app, and the mobile apps, talk to the same RESTful, versioned HTTP API that our Pro and Enterprise customers integrate against. The backend is a large TypeScript codebase (strict mode, all the way) running on Node.js and Express. The API is schema-first: we define it in TypeSpec, compile that to OpenAPI, generate types from it, and validate every request against it at runtime. It's versioned from v1 all the way to v8, meaning five years of evolving the contract without breaking the customers who depend on it. No GraphQL; just a REST API we've invested heavily in.
Our sensors don't speak HTTP. They hold persistent TCP connections over TLS, exchanging Protocol Buffers. So our backend actually runs as two fleets: a smaller one serving the REST API, and a larger one holding tens of thousands of live device connections at once. Keeping that many battery-powered devices connected, in sync, and cheap to talk to is one of the more interesting problems we work on.
Behind the sensors is a data platform that's grown up a lot. We run polyglot persistence: MongoDB as our primary operational database, a relational tier on AWS RDS, Redis for caching and rate-limiting, OpenSearch for device and audit logs, and S3 for objects. Raw per-minute sensor readings are enormous, so we built Granite, an in-house time-series engine that keeps a hot window in SQL and tiers everything else into cheaper cold storage.
For analytics we run a PostgreSQL warehouse that unifies a clone of the backend, the event stream, billing, and hundreds of product-analytics tables into one place we can query.
We don’t disclose scale, but keeping up with growth is one of the most exciting engineering challenges we continuously get to work on. A bug shipped carelessly reaches a lot of homes which is why we take testing and observability seriously (New Relic, Rollbar, Grafana, Prometheus, OpenSearch), and why our CI/CD is fully automated: GitHub Actions with self-hosted runners builds and tests every change, pushes an image to our Docker registry, deploys to Kubernetes, and posts the result to Slack and annotates Grafana. (Jenkins, our 2021 workhorse, is mostly retired now.) All of our infrastructure is Terraform.
This part hasn't changed, because it's the whole point. Privacy-safe monitoring is simple in principle and hard in practice, and we designed a novel way of identifying specific events on battery-powered sensors without compromising guest privacy (US patent US20200143823A1).
Raw data is processed on the sensor directly and never shared with Minut or anyone else. When the device detects a potentially critical event, for instance, glass breaking, a sharp temperature spike, or a sustained rise in noise, it sends a compact fingerprint of that event to the cloud, where more powerful models take a closer look before anything reaches the user. The sensor has no camera and records no audio. It never has, and it never will.
Yes, this still means running trained ML models on a microcontroller with 96 MHz and less than 256 kB of RAM, on battery, up to a year. And the range of things we can detect on-device has grown with cigarette smoke, crowd and occupancy estimation, mould risk, and the sounds of other alarms. Read more about our approach to privacy.
Sensing a problem is half the job. The other half is helping operators act on it without being on call at 3am and that's increasingly where AI shows up in the product.
We're pragmatic about which models we use where. Our customer-facing AI features run on OpenAI (and OpenRouter as a secondary gateway), managed through a versioned, database-backed prompt system so we can iterate on prompts like we iterate on code. A few of the things it powers:
AI runs our entire localization pipeline: translations live as YAML in their own repo, and every push kicks off a GitHub Action that auto-translates into seven languages (Japanese is the newest) and fans the results out to web, backend, storefront, iOS and Android.
Here's the biggest change since 2021, and the one we're most excited about. If OpenAI powers the product, Anthropic's Claude Code powers our engineering and we've leaned into it hard, not as a chat window on the side but as real infrastructure woven through how we work.
Every pull request is reviewed by AI before a human looks at it. A bot runs several coding-agent CLIs in parallel on self-hosted runners doing separate passes for bugs, security, conventions and requirements, plus a consolidation pass with a human-readable "reviewer's guide" to the change. It pulls the relevant Jira ticket for context, posts real inline comments on the exact lines, and once one human approves, it can approve as code owner.
Another set of agents are monitoring releases and continuously doing two things: first, updating internal and external documentation to make sure our support center and team is always up to date. And second, looking for common bugs and fixes that the AI can learn from to improve future development.
Spinning up a new internal tool is one command. Our internal-apps platform (MIAS) provisions a whole production app end to end from a single command: repo, database, auth, hosting, DNS, secrets, registry entry. New apps are agent-native from birth: the scaffolder drops in the context and skills Claude needs, so Claude interviews you about what you're building and then writes the first feature itself. Every app inherits shared sign-in, Slack and email for free, plus a feedback widget that files a ticket straight to the owner with no human triage in between.
The same philosophy runs through our operations. We maintain a shared library of Claude Code skills and subagents that any engineer installs locally for starting a ticket, splitting it across platforms, self-reviewing, debugging a Sentry issue, or shipping.
We have a workflow that takes a production error all the way to a tested draft PR on its own, driving a purpose-built CLI we wrote specifically so an agent could consume it.
None of this replaces engineers. It removes the toil around them such as the boilerplate, the first-pass review, the provisioning, the "why is this error happening" archaeology so the interesting decisions get more of our attention. If building and living inside this kind of setup sounds fun, you'll fit right in.
Minut's mobile apps are still developed natively on both iOS and Android. What's changed is that we're now firmly in the modern, declarative era: iOS is SwiftUI-first and Android is Jetpack Compose-first on Kotlin. Protocol Buffers remain the backbone of how both apps talk to devices, mirroring the firmware.
We still keep an open mind on shared code and development speed, but for us native remains the right foundation.
Since the start, we've designed, prototyped and built our own mechanics, electronics and firmware in-house. We pick the best components and integrate them with our C firmware stack to build a system that respects the privacy of guests by design.
Custom hardware jigs and software, built in-house, collect and upload stats about every unit straight off the manufacturing line, so we can continuously push hardware quality up. Firmware is updated over-the-air after a unit is installed in someone's home; over the years those updates have improved battery performance by more than 100% and added features we hadn't even imagined at launch. We've also built a browser-based Remote Debug Service so we can safely talk to a device in the field for recovery and diagnostics. Enabling all of this is a well-equipped hardware lab at our office in central Malmö.
.png)
To manage sensors in over 100 countries, we've built a rigorous suite of testing and automation to minimize the risk of shipping something that disrupts a sensor a customer's business depends on.
Any developer can bring up a complete environment on their local (or remote) machine, with tools to emulate users, apps and hardware sensors. Our black-box scenario-test suite runs the real backend in Docker against fake versions of every third party we integrate with so we can test whole flows deterministically. And our in-house test fleet of 100+ physical sensors is continuously exposed to different environments, firmware versions, software configurations and routers.
Tools and automation are one half; workflows are the other. Every team uses code review rigorously (now with an AI first pass), pairs frequently, and ships continuously across every part of the stack.
As an engineer at Minut you can work across the whole thing from electronics, to firmware running ML on a tiny microcontroller, to a large TypeScript backend, to animations in a native app, to the agents that build and review it all. We're a truly full-stack organisation, we love what we do, and we're looking for like-minded people to join our growing engineering team.
If that sounds like you, check out our open positions.
