State Synchronization in Smart Homes Using MQTT and Last-Write-Wins

The Consistency Challenge in Residential Networks

When automating a residence, we often deploy multiple small computers across rooms, such as ESP32 boards wired to relays, motion sensors, and smart switches. In practice, this means the living room, kitchen, and office talk to each other without necessarily routing through a heavy central server. The problem arises when two devices try to change the state of the same light fixture at the exact same time, creating an information conflict known as a race condition. Without strict control mechanisms, the system might oscillate and leave residents confused about the actual status of their appliances.

To prevent automation from failing, we must ensure all nodes in the network agree on which command was issued last. In complex corporate architectures, heavy tools like relational databases solve this effortlessly, but in the Internet of Things world, hardware resources are scarce. We need lightweight solutions capable of running on low-power microcontrollers with limited memory while maintaining the reliability of traditional electrical installations.

The Lightweight Message-Based Communication Architecture

The MQTT protocol acts like an efficient and fast postal system where devices publish information to specific topics and other appliances listen to those topics to know what action to take. In practice, when you press a wall switch, it sends a short message stating the switch was activated, and the light fixture listens to this message to change its state. This model drastically reduces network traffic compared to traditional setups based on continuous polling loops.

However, the great flexibility of MQTT introduces an inherent challenge regarding message delivery and event ordering in the network. Because wireless Wi-Fi networks suffer from interference and minor latency jitters, packets sent around the same time may arrive out of sequence at their final destinations. If a command to turn off the light was sent a millisecond before a command to turn it on, but the network delivered the second packet first, the light will turn on instead of off, frustrating user expectations.

Deterministic Conflict Resolution via Last-Write-Wins

To solve the message arrival order problem without requiring a complex centralized server, we use a concept called Last-Write-Wins. In practice, every message sent by a switch or mobile app carries a precise timestamp indicating the exact moment the action occurred. When the actuator receives multiple conflicting commands, it compares the timestamps and accepts only the instruction possessing the most recent time record.

The effectiveness of this approach relies heavily on clock synchronization among all devices in the house. If a switch's clock runs ahead of the others due to minor hardware inaccuracies, it could dominate the network and invalidate legitimate commands originating from other rooms. To bypass this vulnerability, microcontrollers periodically query a local time server within the residential network, securing a uniform and reliable time base.

Practical Implementation on Microcontrollers

Below is a code snippet written in C++ using the PubSubClient library demonstrating how to structure a JSON payload containing both the state and the timestamp on an ESP32.

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

WiFiClient espClient;
PubSubClient client(espClient);

void publishRelayState(bool state) {
  StaticJsonDocument<200> doc;
  doc["state"] = state;
  doc["timestamp"] = millis() + getNtpTimeOffset();
  
  char buffer[256];
  serializeJson(doc, buffer);
  client.publish("home/living_room/light", buffer);
}

The code above encapsulates the logical state of the actuator alongside an integer value representing milliseconds since a common temporal reference. When the receiver processes this payload, it extracts the timestamp field and compares it against the value stored in volatile memory, updating the physical output only if the new time marker is strictly greater.

Final Considerations on Residential Reliability

State synchronization in MQTT-based smart home systems requires a careful balance between protocol simplicity and resilience against network failures. Adopting a deterministic mechanism like Last-Write-Wins eliminates operational ambiguities, ensuring device behavior remains predictable even under adverse connectivity conditions. Investing in a synchronized local time base and structuring messages with proper temporal metadata turns an unstable network into a resilient, high-reliability residential infrastructure.