THE BACKEND THATMAKES YOUR DEVICEPLATFORM WORK
Production-grade IoT API platforms that scale from pilot to global deployment.
Ankh builds the full API platform stack: OpenAPI 3.0 spec-first REST APIs, GraphQL for complex IoT data queries, MQTT and AMQP telemetry ingestion pipelines, OAuth 2.0 and JWT authentication, API gateway design with rate limiting, time-series database optimization in TimescaleDB and InfluxDB, device shadow and command dispatch APIs, multi-tenant SaaS architecture, AWS IoT Core and Azure IoT Hub integration, and SDK generation from OpenAPI specs.
What We Build
REST API Design & OpenAPI 3.0 Spec
OpenAPI 3.0 spec-first design — resource hierarchies, pagination, filtering semantics, and error schemas per IoT conventions, with generated SDKs, mock servers, and validation middleware all derived from the spec.
MQTT & AMQP Telemetry Ingestion
MQTT 3.1.1 and 5.0 with topic namespace design for fleet-scale routing, QoS level selection per data type, and retained message strategy; AMQP 1.0 for enterprise IoT scenarios requiring exactly-once delivery and complex routing topology.
GraphQL for IoT Data Queries
DataLoader-batched resolvers preventing N+1 queries against time-series backends, WebSocket subscription resolvers for real-time sensor feeds, and schema stitching for multi-service IoT platforms.
Device Management APIs
Registration, provisioning, shadow/twin management, command dispatch, and OTA orchestration APIs — including desired/reported state diffing, command queuing with delivery confirmation, and staged rollout with rollback APIs.
Time-Series Database Optimization
TimescaleDB hypertable partitioning, chunk interval optimization, continuous aggregate materialization, and retention policies tuned for IoT patterns — per-device latest value, time-window aggregations, and fleet threshold reports. InfluxDB Flux optimization and 3.0 migration paths supported.
API Gateway Design
Rate limiting per client and endpoint, JWT verification middleware, request/response transformation, mTLS termination for device endpoints, and OpenTelemetry traces — Kong, AWS API Gateway, or Azure API Management per the hosting architecture.
Multi-Tenant SaaS Architecture
Tenant isolation models (shared DB with RLS, schema-per-tenant, or database-per-tenant) with tradeoff analysis for scale and compliance — plus per-tenant rate limits, white-label domains, and tenant-aware middleware.
AWS IoT Core / Azure IoT Hub Integration
Device registry provisioning, certificate-based MQTT authentication, rule engine configuration for telemetry routing, and Jobs API for OTA at scale — with hybrid deployments using managed connectivity alongside custom application-layer APIs.
SDK Generation & Webhook Delivery
Python, TypeScript, and Go SDKs from the OpenAPI spec with IoT-specific template customizations; webhook delivery with at-least-once semantics, exponential backoff, dead-letter queue, and HMAC-SHA256 event signatures.
How We Work
Platform Architecture & API Design
Device-to-cloud data flows, API consumers, and scalability targets are mapped before implementation; the OpenAPI 3.0 spec is written first so client teams build SDKs in parallel. OAuth 2.0 flows, multi-tenancy isolation, and data model trade-offs are all documented before code is written.
Telemetry Pipeline & Database Design
MQTT broker, topic namespace, and QoS assignment per data criticality class are specified before configuration begins. TimescaleDB hypertable chunk intervals, continuous aggregates, and retention policies are designed around dominant query patterns and validated with load tests at representative data volumes.
API Implementation & Authentication
Implementation follows the OpenAPI spec without deviation, with automated contract tests in CI catching drift. OAuth 2.0 covers auth code + PKCE for browsers, client credentials for service-to-service, and device authorization flow for constrained IoT devices; JWT middleware enforces tenant isolation at the gateway.
Device Management & OTA Platform
Device management APIs cover registration, certificate rotation, shadow state with explicit conflict resolution, and OTA campaign orchestration with staged rollout (canary, ring, geographic). The OTA pipeline integrates with firmware signing infrastructure so only signed, anti-rollback-compliant images reach the fleet.
Performance Testing & Scalability Validation
k6 or Locust load tests simulate target device concurrency on the MQTT broker and peak API throughput, with EXPLAIN ANALYZE profiling of slow queries at production-representative data volumes before go-live. The performance report covers p50/p95/p99 latency breakdowns, error rate under load, and extrapolated capacity ceiling.
SDK Delivery & Handoff
Generated SDK code is polished for idiomatic usage — typed models, transparent pagination, retry middleware, and IoT convenience wrappers. Handoff covers architecture decisions, operational runbook, and extension points; a quickstart guide is verified to produce a working API call in under 15 minutes.
Platform Engineering at IoT Scale
Time-Series Database Optimization for IoT
(device_id, time) partitioning that works for per-device queries creates inefficient scans for fleet-wide aggregations — hypertable strategy must match the primary query pattern. Continuous aggregates materialize hourly and daily statistics reducing dashboard latency from seconds to milliseconds; compression on chunks older than one week achieves 20–80x on float telemetry.
Edge Data PipelinesMQTT at Fleet Scale: Topic Design and QoS
QoS 0 suits high-frequency telemetry where loss is acceptable; QoS 1 is required for alarms, state changes, and OTA confirmations; QoS 2 is rarely justified at IoT scale. Retained message strategy and MQTT 5.0 session expiry intervals prevent stale message accumulation and eliminate synchronization RPCs on device reconnect.
Wireless CommunicationSDK Generation: From Spec to Developer Experience
Post-generation customization adds typed model classes, transparent pagination, configurable backoff retry, and idempotency key support — a raw generated client is technically functional but painful to integrate. The SDK test suite validates against a mock server derived from the same OpenAPI spec to catch drift.
Software Development
Production-grade IoT API platforms that scale from pilot to global deployment.
API Platform Development Across Ankh's Product Range
Every connected hardware product needs a backend API platform—and Ankh architects each one to match the data isolation, latency, and compliance requirements of the product category.
Medical Devices
HIPAA Business Associate Agreement, PHI data partitioning, audit logging for all data access operations
View ProductCold Chain Monitoring
Chain-of-custody immutable log API, threshold violation alert delivery, regulatory export endpoints
View ProductIndustrial Equipment Monitoring
OPC-UA to MQTT bridge, edge-first architecture with cloud sync, SCADA integration webhooks
View ProductAI Vision Systems
Inference result ingestion at 30fps per camera, model deployment API for OTA weight updates
View ProductStructural Monitoring
Multi-sensor time-series ingestion, long-horizon trend query optimization, alerting API for structural thresholds
View ProductWearable Electronics
Mobile SDK for BLE data sync, health data FHIR R4 export endpoint, user consent management API
View ProductSmart Home Automation
Matter controller REST API, scene and automation rule management, third-party voice assistant webhook integration
View ProductPower Monitoring
15-minute interval energy data API, utility tariff integration, demand response command dispatch
View ProductData Loggers
Batch upload API for intermittently-connected loggers, conflict resolution for out-of-order telemetry delivery
View ProductWireless Communication
Network topology management API, link quality metrics ingestion, firmware OTA for large node fleets
View ProductHardware-Aware Platform Architecture
MQTT QoS without cellular cost awareness, polling intervals ignoring radio duty-cycle, OTA chunk sizes mismatched to flash write blocks — each surfaces in the field requiring rearchitecting. Platform engineers work alongside firmware teams so device constraints shape the API spec from day one.
Spec-First Development at Every Layer
Resource naming, pagination semantics, and auth scope decisions are locked in the OpenAPI 3.0 spec before any server code is written; contract validation runs in CI against every commit so drift is caught immediately.
Production Operations Readiness
Trace IDs propagated from device MQTT through the API gateway to the database, Prometheus metrics, and OpenTelemetry traces are built in from day one; runbooks covering MQTT connection spikes, compression lag, and OTA rollback scenarios are delivered with the platform.
Deliverables
OpenAPI 3.0 Specification
Complete OpenAPI spec with all endpoints, schemas, security definitions, and examples — the source of truth for SDK generation, mock server, and contract testing.
REST & GraphQL API Server
Production server with auth middleware, input validation, rate limiting, structured logging, and OpenTelemetry instrumentation — containerized with Kubernetes or ECS deployment manifests.
Telemetry Ingestion Pipeline
MQTT broker configuration, topic namespace documentation, consumer service source code, and time-series write path with batch insert optimization and backpressure handling.
Device Management APIs
Device registry, shadow/twin management, command dispatch, and OTA orchestration APIs with integration tests against a device simulator covering all lifecycle state transitions.
Client SDKs
Python, TypeScript, and Go SDKs with idiomatic patterns, retry middleware, typed models, usage examples, and quickstart documentation.
Infrastructure as Code
Terraform or CDK modules for MQTT broker, API gateway, database clusters, message queues, and storage — with staging and production environment configurations.
Performance Test Suite & Report
k6 or Locust load test scripts, performance results at baseline and peak load, p95/p99 latency breakdown, and capacity planning recommendations.
Platform Operations Runbook
Incident scenarios, monitoring dashboard configuration, alerting thresholds, backup and recovery procedures, and 90-day observability baseline with normal metric ranges.
All platform deliverables include source code in version-controlled repositories, infrastructure-as-code, and documentation sufficient for your engineering team to operate and extend the platform.
Often Paired With API Platform Development
Firmware Development
Device-side MQTT client, OTA update agent, and device shadow synchronization firmware co-developed with the platform.
ExploreEmbedded Security
X.509 certificate chain integration with MQTT mTLS authentication, device identity provisioning aligned with platform registration API.
ExploreOTA Firmware
OTA campaign orchestration API co-developed with the device-side update agent for end-to-end OTA pipeline validation.
ExploreEdge Data Pipelines
Edge preprocessing and aggregation pipelines that reduce telemetry volume and latency before delivery to the cloud API ingestion endpoint.
ExploreWork That Demonstrates the Standard
Multi-Tenant IoT Platform for Cold Chain Logistics
Ankh designed a schema-per-tenant TimescaleDB architecture for 120,000 temperature loggers across 40 enterprise customers, with a shared MQTT broker enforcing per-tenant topic ACLs and an OpenAPI 3.0 spec enabling the mobile team to build their SDK in parallel. At 4.2 million messages per day, p99 API latency held below 180 ms with zero SLA breaches across six months.
Read the Case StudyIndustrial Sensor Network REST & GraphQL API
Ankh redesigned GraphQL resolvers using DataLoader batching and replaced per-request aggregations with continuous aggregate materialized views for the 12 most common query patterns against a 2 TB TimescaleDB backend. The most complex dashboard query — 24-hour aggregate for 50 machines, 8 sensor types — dropped from 8.4 s to 0.47 s.
Read the Case StudyReady to build the platform behind your connected product?From first device to fleet scale — we architect it to last.
Tell us your device count and data model and Ankh will scope the architecture, implementation, and operational foundations — from MVP API to production-grade multi-tenant SaaS backend.