Hardware development services for IoT and camera devices

Maxlab is a small hardware team in Edmonton, Alberta, working with companies in the US and Canada. We design the electronics, write the firmware and take the device through certification and into production.

What we build

Most customers come to us with a problem rather than a spec: a prototype that dies on battery in a week, a camera that has to run where there is no mains power, a sensor that must report over a radio from a field. We do the electronics, the firmware, the connection to your system, certification and manufacturing in one team. There is no handoff between a board designer, a firmware contractor and a cloud developer, which is where details get lost. Devices with a camera, a radio or an unusual power budget are the ones we know best.

Electronics and PCB design

We take a device from block diagram to a board that can be built in quantity. That covers the schematic, the choice of parts, the layout and a bill of materials that can be ordered on the day it is needed. We lay out in KiCad or Altium, whichever your team already uses, so you can open and change the files after we are gone.

We pick parts for availability as well as for spec. During the chip shortage we chose the ESP32 for a solar camera partly because it could still be bought in quantity, and the camera reached its production batch. Before a layout is released we check it for manufacturing: footprints, test points, panel layout and whether every part can be placed by machine.

Firmware development

We write firmware in C and C++, and in assembler or Rust where the project calls for it. Most of our boards use the ESP32 family, but the structure is the same on any microcontroller: drivers for each sensor and radio, a power state machine that decides when the device sleeps, and an update path so you can fix a bug after the units are in the field.

For devices that need Linux, we do the bring-up: get the board to boot, get the kernel to see every peripheral, then put the application on top. On the Tokay Lite camera the firmware runs the image sensor, the on-device model, Wi-Fi and BLE, the external RTC that wakes the board from deep sleep, and a web page for configuration that needs no code. That source is on GitHub.

Low-power and wireless devices

Sleep current decides battery life on most small devices. We design the power path, pick a regulator with low quiescent draw, and put the microcontroller into deep sleep between readings, with an external real-time clock or a sensor interrupt to wake it. Done properly, a node runs for years on one battery. Our solar camera runs up to 9 months on one charge with no sun at all.

The radio uses most of the power budget, so we size the battery from the radio's duty cycle and tell you the trade-offs early. Wi-Fi is everywhere but expensive per connection. Bluetooth LE is frugal and short-range. Zigbee needs a gateway; the Zigbee side of our ESP32 Tuya gateway is one we built. If you are still choosing a microcontroller, our guide to low-power MCUs sets out what to compare.

Cameras and edge vision

Our own Tokay Lite is the starting point we offer for camera projects. It pairs an ESP32-S3 with an OV2640 sensor over DVP, adds IR LEDs and a passive-IR motion sensor for night use, and runs a TensorFlow Lite Micro or esp-dl model on the board. The device can decide whether a frame matters before it spends power sending it. If your project fits that envelope, the schematic, layout and firmware already exist and we change only what differs.

For heavier vision we build on Tokay Pro, which runs on an NXP i.MX-class processor. It takes thermal and spectral sensors as well as visible light, tracks more than 100 objects at once and can run from solar.

Connecting the device to your system

Every device we build has to put its data somewhere. We integrate over MQTT and HTTP with AWS IoT, ThingsBoard, Edge Impulse or your own backend. If you have no backend yet, Rainforest IoT, our own platform, gets device data into your system without you writing a server first.

Certification and manufacturing

A board that works on the bench is not a product until it passes FCC, IC or CE and comes off a production line in the quantity you ordered. We handle both. We design to the emissions and safety limits from the first schematic, so the device is not redesigned after a failed test, and we take it through certification for you. We then handle manufacturing: the release package, the first production run and the fixes the first run turns up. The waterproof camera went from first sketches to its first manufacturing batch in under 9 months, and the enclosure was designed in-house along with the board.

Projects we have shipped

Four devices that went past the prototype stage. Each one links to its full write-up.

Tokay Lite, open-source edge AI camera

An ESP32-S3 camera and dev board, sold on Mouser and launched on CrowdSupply. The hard part was fitting a working vision pipeline into a microcontroller: 8 MB of flash, 8 MB of external RAM, an OV2640 running at up to 15 FPS, and a programmable external RTC so the board can sleep and wake on a timer. The schematic, layout and SDK are public on GitHub, with documentation at docs.maxlab.io. You can inspect the work before you call us.

ESP32 Tuya gateway

A gateway that connects Tuya devices on a local network without Tuya's cloud. It exposes an MQTT and HTTP API and plugs into Home Assistant, so the devices keep working when the internet is down. It shows we can build the gateway side of a wireless system, Zigbee included, and ship it as a product. The Tuya gateway page ranks first in the US for "tuya gateway".

Solar waterproof camera

A roof-monitoring camera for remote properties, described on its portfolio page: ESP32, solar panel, UV-resistant Lexan enclosure, HD photos through the year. The hard part was power. The camera has to get through winter on little sun, and it runs up to 9 months on one battery charge with no sun at all. It went from first sketches to the first manufacturing batch in under 9 months, through several board revisions. The ESP32 was chosen partly because it could be bought during the chip shortage.

12-channel energy monitor

A device that measures 12 circuits at once and sends live readings to a phone app over Wi-Fi or Bluetooth, with an alert when one circuit draws more than it should. One team did the analog measurement, the two radios and the firmware. The energy monitor page has the details.

Other past work includes methane detection, smart parking and power management for rooftop ice-melt cables.

How a project runs

Each stage ends with files or hardware you keep. If you stop after any stage, you walk away with what has been made so far, and the design files are yours.

1. Requirements

We start with a 30-minute intro call, under NDA if you want one. We ask more questions than you expect: what the device does, how it is powered, where it lives, what it talks to, how many you plan to build. You get a written summary of the device as we understand it and a proposal for the next stage.

2. Proof of concept

Where a part of the design is uncertain, such as battery life or a camera's low-light performance, we test it on development boards before committing to a layout. You get measured numbers and a go or no-go on the risky part.

3. Schematic and layout

We choose parts for availability and spec, draw the schematic, lay out the board in KiCad or Altium and check it for manufacturing. You get the schematic, the layout files, the BOM and the fabrication outputs.

4. Prototype and bring-up

We have a small batch of boards made and assembled, then bring them up: power rails first, then the processor, then each peripheral. Firmware starts here. You get working prototypes and the first firmware build.

5. Testing and revisions

Prototypes go through power measurement, radio range, temperature and whatever your use case demands. Most designs take more than one revision; the solar camera took several. You get a test report and a revised board.

6. Certification

We prepare the device for FCC, IC or CE as the market requires and take it through testing. If something fails, we fix the board and retest. You get the certified design and the test results.

7. Pre-production

We freeze the design and prepare the release package: fabrication and assembly files, assembly notes, a test procedure and a production firmware image. A small pilot run checks that the package builds the device as drawn. You get the release package and the pilot units.

8. Manufacturing

We handle the production run in the quantity you need and fix what the first run turns up. You get finished devices, and the design files, layout and firmware source are yours to keep.

After launch we keep updating the firmware as you find bugs and ask for features. Devices in the field get the update over the air if the design includes it.

Who we are

Maxlab is a team of about seven based in Edmonton, Alberta. We provide hardware development services to companies across the US and Canada and work remotely. We design in KiCad and Altium, write in C, C++, Rust and assembler, and build most often on the ESP32 family and NXP i.MX-class processors. Our customers work in manufacturing, agriculture, robotics, logistics, recycling and wildlife monitoring. We sign an NDA before the first call if you ask, and have our own template if you don't. There is more on the about us page.

Next step

Send us a description of the device, however rough. We reply within 24 hours and will tell you on the first call whether it is a fit. Book a 30-minute call or send us your project. You can also email hi@maxlab.io or call +1 587 557 5865.

Common questions