Skip to content

IoT & Embedded Systems Development

Engineering rugged, battery-optimized, and cloud-connected hardware solutions. From physical schematic design to production firmware and telemetry dashboards.

Custom Firmware (ESP32, STM32, RP2040)
High-Quality Schematic & 2-4 Layer PCB Design
Battery & Sleep-Cycle Power Optimization
Sensor Fusion & Edge AI Inference
Robust MQTT, WebSocket, and HTTP Data Pipelines
Over-the-Air (OTA) Secure Update Deployment
Core Track Record

4+ Years

Building systems

Collaboration Mode

Remote + Onsite (Guwahati Area)

Concept Validation → Custom PCB Prototype → Production-Ready Firmware

Platforms Used
ESP32-S3STM32F4Raspberry PiFreeRTOS

Optimization Summary

Summary: Many IoT projects fail because the hardware designer and firmware coder operate in silos. I handle both, preventing common integration bottlenecks.

Common Obstacle

Existing ESP32 firmware is unstable and disconnects from Wi-Fi constantly.

Engineering Resolution

I implement non-blocking reconnection loops, auto-refreshing TLS certificates, offline network caching inside Flash (SPIFFS/LittleFS), and watchdog timers (WDT) to auto-recover hung threads.

Common Obstacle

Batteries drain in days instead of months.

Engineering Resolution

I replace simple delay loops with deep-sleep RTC timers. I calibrate physical wake interrupts, isolate high-draw sensors using P-channel MOSFET power gates, and configure low-power state machines.

Common Obstacle

Updating deployed devices requires physical disassembly.

Engineering Resolution

I build partition-safe OTA (Over-The-Air) update engines over HTTPS with hash verification. Deployed devices download and flash updates automatically, with automatic rollbacks on boot failure.

Common Obstacle

Telemetry lag is too high to coordinate movements.

Engineering Resolution

I replace high-overhead HTTP requests with ultra-low latency WebSocket loops or structured MQTT binary payloads (Protocol Buffers) running on lightweight transport layers.

Is This Service Right For You?

Summary: I partner with teams and builders requiring direct access to the developer writing both the hardware firmware and the cloud logic. I do not delegate to junior engineers.

Startups & Product Innovators

Teams that need a functional prototype fast. I build the physical hardware, flash initial firmware, and deliver a visual cloud dashboard within weeks to validate market fit.

Research Labs & Universities

Academic projects needing bespoke sensor arrays, high-speed telemetry loggers, or gesture-controlled actuators (like my 6-DOF robotic arm gesture pipeline).

Agricultural & Environmental Businesses

Operators requiring solar-powered, ruggedized sensor packages for soil moisture, nitrate monitoring, or microclimate telemetry deployed in isolated fields.

Industrial & Manufacturing Teams

Companies seeking to retrofit legacy machinery with Modbus/CAN telemetry adapters to push operational metrics to secure cloud endpoints.

Typical Engineering Deliverables

Summary: At the end of a project, you receive 100% of the IP. No vendor lock-in or proprietary dependencies.

Hardware

KiCad Design Source Files

Fully routed schematics, 2/4-layer layout files, and customized component libraries built in KiCad.

Hardware

Gerber & Fabrication Packages

Production-ready Gerber files, drill files, BOM (Bill of Materials) with active LCSC/DigiKey part numbers, and pick-and-place coordinate maps.

Software

Firmware Source Code & Binaries

Clean, documented C++ or C firmware source code structured under PlatformIO or ESP-IDF, alongside pre-compiled flashing binaries.

Mechanical

CAD Modeling & 3D Enclosure Files

Parametric 3D CAD files (STEP/STL formats) for physical enclosures designed for FDM printing or injection molding.

Documentation

API & Protocol Documentation

Clear Markdown specifications outlining the telemetry JSON structure, MQTT topics, security handshake steps, and device variables.

Specialized Building Areas

Summary: I build physical devices engineered to capture environmental telemetry, translate physical motions, and execute local logic.

Edge AI & Wake Word Inference

Running neural networks locally. I deploy TensorFlow Lite for Microcontrollers on ESP32-S3 boards to perform local audio wakeword detection (similar to the SmartPot companion) and real-time sensor anomaly classification with sub-100ms response windows and zero cloud bandwidth dependency.

Bespoke Embedded Telemetry Nodes

Custom telemetry rigs monitoring physical variables. I design integrated PCB circuits utilizing I2C, SPI, and UART lines to read analog gas sensors, capacitive soil moisture probes, multi-axis accelerometers, and thermal arrays, compiling them into packed payloads.

Gesture-Controlled Actuation

Bridging computer vision and physical machinery. I construct multi-axis motor controllers (such as gesture-mapped robotic arms) communicating via high-speed WebSockets to convert camera joint coordinates into PWM pulses on servo drivers.

Technical Stack & Platform Coverage

Summary: I write low-level code and design physical boards using industry standard tools.

Microcontrollers & SoCs

ESP32-S3 / ESP32-C3STM32F103 / STM32F4RP2040 (Raspberry Pi Pico)ATmega328P / Arduino

Design & CAD Tools

KiCad (Schematic & Layout)Fusion 360 (Enclosures)PlatformIO / VS CodeESP-IDF / Arduino CLI

Protocols & Radios

MQTT / MosquittoWebSockets / HTTPBLE (Bluetooth Low Energy)LoRa / ESP-NOWI2C / SPI / UART / CAN

AI & Telemetry Backend

TensorFlow Lite for MicrocontrollersEdge ImpulseNode-REDNext.js / TailwindSupabase / PostgreSQL
Related Technologies:ESP32FreeRTOSMQTTBLEKiCadEdge AI
Deep Technical Documentation

Engineering Notes & Tradeoffs

Detailed Technical Deep Dive: IoT & Embedded Systems

Summary: This document outlines Jishnu Mahanta's architectural approach to engineering battery-powered sensor networks, writing clean, firmware layers, and developing physical enclosures.

1. Power Management & Sleep Cycle Calibration

In field deployments, battery life is the ultimate constraint. A standard ESP32 drawing 80mA to 240mA during active operation will drain a 1200mAh LiPo battery in a matter of hours. Achieving a multi-year battery life requires shifting from active polling to event-driven execution and strict sleep-cycle profiles.

Power Consumption during Reconnection

Battery-powered ESP32 devices often consume far more power during Wi-Fi reconnect loops (drawing 150mA+ for 5-15 seconds) than in deep sleep (10µA to 15µA). If a Wi-Fi router is temporarily offline, a naive loop will rapidly drain the battery. Optimizing reconnect intervals with exponential backoff and localized flash caching usually has a larger impact than reducing the CPU frequency.

To optimize power draw, the hardware design must isolate high-power sensors (such as gas sensors or GPS receivers) using P-channel MOSFET power gates. Below is the standard firmware pattern I implement in C++ using ESP-IDF to coordinate deep sleep intervals and interrupt-driven wake cycles:

#include "esp_sleep.h"
#include "driver/rtc_io.h"

#define SENSOR_POWER_PIN GPIO_NUM_4
#define WAKE_UP_PIN GPIO_NUM_12

void setup() {
  // Initialize RTC variables
  esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
  
  if (wakeup_reason == ESP_SLEEP_WAKEUP_EXT0) {
    // Handle sensor trigger interrupt (e.g. rain sensor or tilt sensor)
    processSensorInterrupt();
  } else {
    // Regular scheduled telemetry upload
    performTelemetryRoutine();
  }
  
  // Power down peripheral rail before sleep
  pinMode(SENSOR_POWER_PIN, OUTPUT);
  digitalWrite(SENSOR_POWER_PIN, LOW); // Cut power to MOSFET gate
  
  // Configure external pin wake trigger (active low)
  esp_sleep_enable_ext0_wakeup(WAKE_UP_PIN, 0); 
  
  // Configure timer wake (e.g. 1 hour = 3600 seconds)
  esp_sleep_enable_timer_wakeup(3600ULL * 1000000ULL);
  
  // Start deep sleep
  esp_deep_sleep_start();
}

RTC Fast Memory Usage

When using deep sleep, standard RAM is powered off, losing all state variables. Instead of repeatedly writing configurations to Flash memory (which has limited write cycles), variables should be annotated with the RTC_DATA_ATTR attribute to preserve them in RTC fast memory.


2. Physical Layout Design & High-Speed Routing Rules

When routing 2-to-4 layer PCBs in KiCad, high-frequency signals (such as USB-C data lanes or high-speed SPI busses) must be laid out with impedance matching and proper return paths.

Floating Ground Planes & EMI Loops

A common mistake is routing high-speed signal traces directly across gaps in the ground return plane. This forces return currents to flow in a large loop, creating a loop antenna that emits electromagnetic interference (EMI) and corrupts sensitive analog sensor readings.

Impedance Rules for High-Speed Data Lines:

  • Ground Return: Always place a solid, continuous copper ground plane directly beneath signal tracks on Layer 2.
  • Differential Pairs: USB data lines must be routed as a differential pair with matched trace lengths (within 0.15mm) and a constant spacing to maintain a 90-ohm differential impedance.
  • Power Decoupling: Position 0.1µF and 10µF ceramic capacitors within 2mm of the VCC input pins of microcontrollers to filter high-frequency switching noise.

The SmartPot Bring-up

During the SmartPot bring-up phase, the initial draft had noise interference on the capacitive soil moisture lines. I isolated the analog tracer, surrounded it with a copper ground fill guard ring, and placed an active RC low-pass filter (10kΩ resistor + 1nF capacitor) close to the ADC pin. This reduced reading variance from ±8% to a stable ±0.2%.


3. Firmware Architecture & FreeRTOS Decoupling

Modern IoT edge nodes handle multiple concurrent processes: updating a display, measuring sensors, listening to voice commands, and communicating over MQTT. Running these inside a single blocking loop leads to system lag. I build modular firmware structures by utilizing FreeRTOS queues and task prioritization:

  +--------------------+      Queue      +---------------------+
  | Sensor Polling     | ---------------> | MQTT Telemetry Sync |
  | (Priority 1, 10Hz) |                  | (Priority 2, Event) |
  +--------------------+                  +---------------------+
            |                                        |
            v                                        v
  Reads ADC / I2C / SPI                     Pipes packets over TLS

This decoupling ensures that if network latency increases during telemetry transfer, sensor measurements continue to run at stable intervals. If a task crashes, a dedicated supervisor task detects the failure and resets only the affected subsystem rather than restarting the entire board.

My Development Process

Summary: I build hardware systematically, ensuring physical errors are caught early during simulation and visual modeling.

01. Discovery & Specifications

Scoping the Hardware Boundary

Phase 1 of 9

We outline constraints: battery target lifespan, size dimensions, operating temperature, radio range, and component costs. I draft a clear block diagram detailing microcontrollers, power chips, sensors, and flash allocations.

Featured Project Deliverables

Dynamic projects fetched from the portfolio database demonstrating execution.

SmartPot plant sensor
IoT
Edge AIVoice Control

SmartPot — AI Plant Companion

Voice-controlled ESP32 plant assistant with edge AI and sensor intelligence.

ESP32FreeRTOSTensorFlow LiteMQTT

Firmware & AI Systems Engineer

View Details →
Robotic arm
IoT
RoboticsComputer Vision

Smart Robotic Arm

Gesture-controlled multi-axis arm with computer vision.

ESP32OpenCVMediaPipeWebSockets

Firmware & System Engineer

View Details →
Garden sensor
IoT
AutomationSustainability

Garden Automation

AI-driven irrigation system for optimal plant health.

IoTGSMSensorsCloud Logging

IoT Developer

View Details →
Fish feeder device
IoT
IoTWeb Control

Smart IoT Fish Feeder

Remote-controlled automated feeding system.

ESP32Next.jsServoFirebase

Full-stack IoT

View Details →
Weather station
IoT
Real-time displaySensor + API fusion

Live Weather Monitoring System

Real-time display with sensor fusion & API data

ESP32NodeMCUBME280OpenWeatherMap API

IoT Engineer

View Details →

Why Hire a Full-Stack Hardware Engineer?

Summary: Agencies often require separate hardware and software teams, doubling your coordination overhead and budget.

Engineering CriteriaMy Freelance ServicesTypical Development Agency
Direct Developer Communication✓ Instant Slack/WhatsApp contact with the engineer writing your code.❌ Relies on account managers; responses take 24–48 hours.
PCB + Firmware + Cloud Integration✓ Done by a single engineer, ensuring perfect hardware/software synergy.⚠️ Split across departments; frequent miscommunication on APIs.
Source Code & Schematic IP Ownership✓ 100% IP transferred to you on completion; zero recurring platform fees.⚠️ Often retains core firmware blocks or charges licensing.
Edge AI & TFLite Optimization✓ Experienced in squeezing neural networks onto low-cost ESP32 chips.❌ Typically pushes AI logic to cloud APIs, increasing latency/cost.
3D CAD Enclosure Integration✓ Custom enclosure design matching the routed PCB geometry.❌ Requires hiring a separate mechanical design contractor.

Coverage Area & Physical Location

Summary: Based in Guwahati, I provide custom hardware prototyping and telemetry sensor setups statewide across Assam. Physical delivery and on-site debugging are available in Jorhat, Dibrugarh, Silchar, Nagaon, and Tezpur.

On-site Delivery Areas

Guwahati
Jorhat
Dibrugarh
Silchar
Nagaon
Tezpur
Tinsukia
Sivasagar
Golaghat
Barpeta
North Lakhimpur
Bongaigaon
Dhubri
Kokrajhar
Hailakandi
Karimganj

Remote Collaboration

For clients across other major Indian tech hubs (Bengaluru, Hyderabad, Pune, Chennai, Mumbai, Delhi NCR) and global locations (US, Canada, UK, Australia, Germany, Singapore), I provide remote collaboration via GitHub, sandbox database integrations, and international shipping.

Base: Guwahati, Assam, IndiaGSC Verified

Deep Technical Guides & Resources

Summary: Read how I evaluate components and protocols when designing custom systems.

8 min read

ESP32 vs STM32: Choosing the Right Microcontroller

An engineering evaluation comparing ESP32's built-in Wi-Fi/Bluetooth against STM32's deterministic real-time processing and low-power registers.

6 min read

MQTT vs WebSockets: Optimizing IoT Telemetry Pipelines

Analyzing packet overhead, handshake protocols, and connection stability for low-bandwidth cellular connections.

11 min read

Calibrating ESP32 Deep Sleep and MOSFET Gates for 1-Year Battery Lifespan

Detailed schematics showing how to bypass voltage regulators and power down sensors completely using P-MOS switches.

Frequently Asked Questions

Structured query answers targeting specific informational searches.

I handle the complete design, routing, and component sourcing. For physical fabrication, I export industry-standard Gerber files and send them to local or global fabrication shops (like PCBWay or JLCPCB) to assemble and ship to my lab.
Yes. By using TensorFlow Lite for Microcontrollers, I compile optimized, quantized models that fit inside the ESP32-S3's RAM. This allows on-device wake-word analysis or motion pattern classification.
Yes, I provide standard support for 30 days post-delivery. I also offer long-term support contracts to address security patches, library updates, and OTA server maintenance.
I enforce MQTTS (MQTT over TLS) or HTTPS protocols, flashing individual, unique private keys onto each device. We restrict database write APIs through secure tokens and restrict server endpoints.

Let's Build Your Connected Device

Ready to move from a breadboard to a production-ready custom PCB and firmware framework? Schedule a direct engineering call.

FyraAsk anything