I wrote a blog post about this idea in 2014.
At the time, the conversation revolved around what people were calling the Internet of Things. The prediction was straightforward: billions of small devices would soon be connected to the network.
Sensors. Thermostats. Locks. Cameras. Industrial instruments.
Many forecasts were ambitious. Some analysts suggested there might be forty billion connected devices by 2020.
The exact numbers turned out to matter less than the architectural question those predictions raised. What happens when the network is no longer mostly computers and phones, but millions—or billions—of tiny, single-purpose devices?
Small machines behave differently
Traditional software assumes relatively capable machines. A typical program runs on a computer with ample memory, stable connectivity, and the ability to execute complex instructions. Much of modern programming evolved in that environment.
But many connected devices are nothing like that.
They are small, often battery powered, and sometimes barely programmable at all. In many cases they are better understood not as computers but as instruments. They measure temperature, detect motion, count rotations, open valves, or switch circuits.
Each device performs a narrow function, but it does that job reliably and continuously.
When systems are built from large numbers of these simple components, the traditional model of step-by-step programming begins to strain.
Instructions vs rules
Most software is written as a sequence of instructions. A program executes one step, then another, following a detailed path laid out by its developers.
That approach works well when a program controls a single machine or a tightly bounded system. Distributed environments behave differently. Instead of one program directing everything, there are many small components reacting to events in the world around them.
In these situations, rules often work better than instructions.
Rather than scripting every step, the system defines relationships between conditions and actions. If a temperature crosses a threshold, a fan activates. If motion is detected while a system is armed, an alert is triggered. Components respond to signals rather than waiting for a central controller to tell them exactly what to do next.
Large distributed systems work best when we stop trying to control every step and instead define the rules under which the system operates.
Local decisions
One early concern about large networks of connected devices was traffic. If every sensor and actuator had to constantly contact a central system for instructions, the network would quickly become congested and response times would degrade.
The last decade produced a practical compromise.
Much of the coordination and large-scale analysis happens in centralized cloud systems. At the same time, many immediate decisions are made closer to where events occur. Edge devices and gateways evaluate simple rules locally, filtering signals and forwarding only meaningful information upstream.
The result is a layered architecture in which the edge reacts quickly while the cloud coordinates and analyzes at scale.
A broader architectural pattern
What began as a discussion about connected devices has gradually revealed a broader pattern in modern software architecture. Large distributed systems increasingly rely on events, rules, and policies rather than tightly scripted programs. Components observe conditions, evaluate constraints, and trigger actions across a network of cooperating systems.
Instead of writing one large program that controls everything, we assemble systems from many smaller parts that respond to signals and context. The shift is subtle but important. Behavior emerges from interactions rather than from a single sequence of instructions.
Still an open question
Over the past decade the cloud has remained a powerful coordinating center for these systems. Data aggregation, analytics, and machine learning models are often concentrated there.
But the balance between centralized control and distributed decision making is still evolving. As devices grow more capable and networks continue to expand, more responsibility may move outward toward the edge.
If that happens, the architectural lesson remains the same.
Large distributed systems work best when we stop trying to control every step and instead define the rules under which the system operates.
The next big thing, it turns out, is still small.
