Internet of Things

IoT software, from devices to cloud services

I work on gateway software, telemetry pipelines, device authentication, and digital twin models. My projects connect physical devices with the backend services that process their data.

I focus on what happens when connections drop, data arrives late, or a device needs new credentials, and how engineers can investigate those problems.

Rust, Java, Scala, MQTT, Kafka, and OpenTelemetry.

Main areas of work

Message delivery

Buffering messages, retrying failed sends, and controlling data flow when a receiver cannot keep up.

Monitoring and debugging

Logs, metrics, and traces that show how gateways and telemetry pipelines are behaving.

Device security

TLS and mTLS, device identity, and certificate management for communication between devices and services.

Engineering focus

Message handling

Buffering, retries, and backpressure for messages sent from devices to backend services.

Device and transport security

mTLS, device identity, key handling, and secure gateway configuration.

Monitoring and debugging

Metrics, traces, logs, and alerts for investigating failures.

Architecture decisions

Choosing protocols, storage, data processing, and deployment methods for the devices and services involved.

Implementation

Gateways, telemetry, and backend services

I build edge gateway software and telemetry pipelines. This includes queueing messages during outages, retrying failed deliveries, handling duplicates, and recovering when a connection returns.

My projects use Rust for gateway software and probes, Scala for backend processing, Java/Spring Boot for APIs, and Apache Kafka for event streaming. I use OpenTelemetry, structured logs, metrics, and alerts to make failures easier to investigate.

My security work includes TLS/mTLS, device authentication, key handling, and certificate lifecycle management. The certificate control plane project covers inventory, expiry tracking, and renewal workflows for IoT fleets.

RustScalaJava/SpringIoT GatewayMQTTgRPCKafkaOpenTelemetrymTLSPrometheus/GrafanaEdge AICloud Integration

System design

Design questions I work through

Disconnections and recovery

Where are messages stored during a disconnection? How are they sent after recovery, and how does the receiver handle duplicates or detect missing data?

Device identity

How is a device authenticated? Who renews its certificates, and what happens when a credential expires or must be revoked?

Diagnosing failures

Can an engineer trace a message from the device to the backend and identify where it was delayed, changed, or lost?

Research and modeling

Connecting device data to system models

Devices have limited memory, intermittent connections, and different sampling rates. Backend services need to account for those limits when processing telemetry and maintaining a model of the system.

My digital twin work explores how measurements from individual devices can be combined into a model of a larger system. I document these models and the gateway designs in project write-ups and technical articles.

Digital twin hierarchy tree diagram
A digital twin hierarchy groups sensor measurements by device and system, so readings can be compared and aggregated at different levels.

Technical areas

Data processing, device state, and monitoring

Streaming telemetry and data pipelines

I work with telemetry collection and processing from distributed devices. This includes message formats, buffering and retries, schema changes, and integration with analytics and monitoring systems.

The work involves protocols such as MQTT, gRPC, HTTP, and WebSockets, along with data formats suited to the volume of messages. Processing pipelines filter, join, and aggregate measurements from multiple sources.

Digital twins and system state

I model how devices relate to one another and how their measurements describe the state of a larger system. My virtual power plant project explored this using digital twins and streaming telemetry.

These models need to distinguish current readings from stale or missing data. Timeouts, delayed updates, and disconnected devices must be visible to anyone using the model.

Device metadata and data quality

Device metadata helps explain where a measurement came from and whether it can be used. I work with metadata models and checks for connection status, ingestion errors, and data quality.

Useful measurements include the proportion of devices connected, parsing error rates, and messages that do not match the expected schema.

Location data from connected devices

Location data adds context to measurements from moving devices. It can be used to monitor vehicles, compare routes, and relate sensor readings to where they were recorded.

For more on gateway design, read Designing a Secure Rust-Based IoT Gateway.

Diagrams and data

Examples from my projects

Secure IoT edge gateway cloud context diagram
Device, gateway, and cloud connections in the secure IoT architecture.
IoT runtime platform model
Software components and responsibilities across the device, gateway, and cloud.
Telemetry sensor data visualization
Aircraft engine sensor readings used for data analysis.

Implementation notes

Handling failures in connected systems

Common failure cases include a gateway restarting with queued messages, a device sending an unexpected payload, and a connection dropping during delivery. I use these cases to guide message handling and recovery design.

I consider how protocol choices, message schemas, and security settings will work across devices with different firmware versions and connection quality.

Logs, metrics, and repeatable tests help check whether recovery works as intended. I prefer to address one failure case at a time and verify the behavior before moving on.

For full architecture detail, read the Rust IoT gateway article.

Projects

Selected IoT projects

Projects covering device data, gateway software, and backend processing.

Questions about a project? Get in touch.

View all projects →