On-Device, Edge, and Cloud Computing
This article explores the differences between on-device, edge, and cloud computing, and when each approach makes the most sense.
From processing data directly on a device to sending it to nearby edge servers or distant cloud infrastructure, modern applications have more choices than ever about where computation should happen.
1. What is On-Device Computing?
Many devices, such as robots, drones, autonomous vehicles, and IoT devices, have computers built into them to perform processing.
For example, a robot can process sensor data to control its motors. A drone can process data from its camera, GPS, accelerometer, and gyroscope to maintain stability and navigate. Similarly, a smart camera can process captured images to detect motion or objects.
However, devices, especially embedded systems, have limited computing resources compared to modern computers and servers.
An embedded device may have:
- A relatively low-performance processor
- Limited memory and storage
- Limited power
- Limited cooling capacity
This is mainly because embedded devices are designed to be cost-effective, compact, and energy-efficient.
For example, a battery-powered drone cannot use a large server-class processor because the processor would consume too much power and generate excessive heat. Similarly, adding powerful hardware to a low-cost IoT device would increase its manufacturing cost.
What Can Be Processed On-Device?
Despite these limitations, many tasks can be performed directly on the device.
For example, a device can perform:
- Sensor data processing
- Signal filtering
- Motor and actuator control
- Measurement and monitoring
- Event detection
- Real-time control
- Simple decision-making
These operations generally do not require a large amount of computing power.
What Cann NOT Be Processed On-Deive?
However, some tasks require significantly more computing resources than it is practical to provide on the device.
Examples include:
- Running large AI models
- Processing high-resolution images and videos
- Training machine-learning models
- Performing complex simulations
- Processing large datasets
- Solving computationally intensive optimization problems
Powerful Computers to Help the Device
In such cases, the device can send the data to another, more powerful computer over a network.
The powerful computer performs the required computation and sends the result back to the device.
For example, a camera may capture an image and send it to a server for object detection. The server performs the AI computation and returns the detected objects to the camera.
Similarly, a robot may send sensor data to a powerful computer for complex path planning, or a device may send audio to a remote computer for speech recognition.
The important question, therefore, is where the computation should be performed.
If the computation is performed directly on the device that generates the data, it is called on-device computing.
The next question is what happens when the computation is moved from the device to a nearby computer or a remote server. This leads to the concepts of edge computing and cloud computing.
2. What is Off-Device Computing?
In on-device computing, the device collects data and processes it using its own processor. However, the device does not necessarily have to perform all of the required computation itself. It can send the data to another computer and use that computer to perform the computation. This approach is known as off-device computing.
Off-device computing is a computing model in which a device sends data to another computer for processing instead of performing the computation locally.
The basic difference can be seen by comparing the two models.
On-device computing:
┌───────────────┐
│ Device │
│ │
│ Sensors │
│ │ │
│ ▼ │
│ Processing │
│ │ │
│ ▼ │
│ Result │
└───────────────┘
Off-device computing:
┌───────────────┐ ┌──────────────────┐
│ Device │ │ Other Computer │
│ │ │ │
│ Sensors ───┼── Data ─►│ Processing │
│ │ │ │ │
│ ▲ │ │ ▼ │
│ └───────┼─ Result ─│ Result │
│ │ │ │
└───────────────┘ └──────────────────┘
For example, a camera can capture an image and send it to another computer for image processing. A robot can send sensor data to another computer to perform path planning. Similarly, a smartphone can send audio to another computer for speech recognition.
The other computer can be a nearby computer, an edge server, or a remote cloud server. The important point is that the computation is performed outside the device itself.
Off-device computing therefore allows a device with limited computing resources to use the computing resources of another, more powerful computer.
The location of this other computer and the way the device communicates with it lead to different forms of off-device computing, including edge computing and cloud computing.
3. The Problem with Off-Device Computing: Latency
Off-device computing allows a device to use the computing resources of another, more powerful computer. However, moving the computation outside the device introduces an important problem: latency.
When a device sends data to another computer, the data must travel through a communication network. The device must wait for the data to reach the computing server, for the server to perform the computation, and for the result to travel back to the device.
For example, consider a robot that sends sensor data to another computer for processing.
Robot
│
│ Send Data
▼
Computing Server
│
│ Process Data
▼
Result
│
│ Send Result
▼
Robot
The total time required for this process depends not only on the computation performed by the server but also on the time required to transfer the data between the device and the server.
This becomes particularly important for applications that require fast responses. For example, a robot controlling a moving object, an autonomous vehicle detecting an obstacle, or an industrial controller responding to a machine event may need the result within a very short time.
Therefore, when using off-device computing, it is often important to place the computing server physically close to the device.
Why Should the Computing Server Be Physically Close?
The physical distance between the device and the computing server affects the network path through which the data must travel.
A server located far away may require the data to travel through many network links before reaching the server. A server located nearby can often be reached through a shorter network path.
For example, a robot and an edge server may be located in the same building and connected through a high-speed local network.
┌───────────────┐
│ Robot │
└───────┬───────┘
│
│ High-Speed Network
│
┌───────▼───────┐
│ Edge Server │
└───────────────┘
The edge server does not necessarily have to be inside the same building. It may be located somewhere else on the same campus, in the same city, or within the same geographical region.
Possible Deployment Scenarios
The computing server used for off-device processing can be placed at different geographical locations depending on the application.
For example, consider a robot operating inside a university campus. The robot could communicate with an edge server located in the same laboratory or building.
Robot
│
│ High-Speed Local Network
▼
Edge Server
(Same Building)
The server could also be located elsewhere on the same campus.
Robot
│
▼
Campus Network
│
▼
Edge Server
(Same Campus)
For a city-wide deployment, an edge server could be located within the same city or geographical region as the devices.
Devices
│
▼
Local Network
│
▼
Edge Server
(Same City / Region)
In other cases, the computing server may be located in another country or geographical region. This is common when using public cloud infrastructure.
For example, cloud providers such as AWS and DigitalOcean allow users to select the geographical region in which their servers are deployed. A user can therefore select a server location that is geographically closer to the devices generating the data.
The possible locations can therefore range from a computer in the same building to a server in another geographical region:
Device
│
├── Same Building
│
├── Same Campus
│
├── Same City
│
├── Same Region
│
└── Different Country
│
▼
Computing Server
The farther the computing server is from the device, the more network infrastructure may be involved in transferring the data. Therefore, the physical and network location of the computing resource is an important consideration when designing an off-device computing system.
This requirement to place computing resources closer to the devices is one of the main ideas behind edge computing.
4. What is Edge Computing?
As discussed in the previous section, the computing server used for off-device processing can be placed at different physical locations. When the computing resources are placed close to the devices that generate the data, the approach is commonly referred to as edge computing.
Edge computing is a form of off-device computing in which data is processed close to the device that generates the data.
For example, a robot may send its sensor data to an edge server located in the same laboratory or building.
┌───────────────┐ ┌────────────────┐
│ Robot │ │ Edge Server │
│ │ │ │
│ Sensors ───┼── Data ─►│ Processing │
│ │ │ │ │
│ ▲ │ │ ▼ │
│ └───────┼─ Result ─│ Result │
└───────────────┘ └────────────────┘
The edge server is a separate computer, so this is not on-device computing. However, it is close to the device, unlike a typical remote cloud server.
An edge server can be located in the same building, on the same campus, within a factory, or somewhere else within the same geographical region.
For example, a factory may have several cameras and sensors connected to an edge server located inside the factory. The edge server can process the data generated by these devices without requiring the devices to send all of their data to a remote cloud server.
Edge computing therefore provides a way for devices with limited computing resources to use more powerful computers while keeping those computing resources relatively close to the devices.
In simple terms:
On-Device Computing
Device ──► Device Processor
│
▼
Result
Edge Computing
Device ──► Nearby Edge Server
│
▼
Result
The key idea is that computation is moved off the device, but the computing resource is kept close to the device.
5. What is Cloud Computing?
Edge computing places computing resources close to the devices that generate data. However, it is not always practical or necessary to keep all computing resources near the devices.
Instead, the computation can be performed by powerful computers located in large data centers. These computers can be accessed over a network and are commonly referred to as cloud computing.
Cloud computing is a computing model in which computing resources such as processors, memory, storage, and software are provided through a network, typically from remote data centers.
For example, a device can send its data to a cloud server, where the data is processed and the result is returned to the device.
┌───────────────┐ ┌──────────────────┐
│ Device │ │ Cloud Server │
│ │ │ │
│ Sensors ───┼── Data ─►│ Processing │
│ │ │ │ │
│ ▲ │ │ ▼ │
│ └───────┼─ Result ─│ Result │
└───────────────┘ └──────────────────┘
Unlike an edge server, a cloud server does not need to be physically close to the device. Cloud providers operate large data centers in different geographical locations and provide computing resources to users over the Internet.
For example, a company may deploy an application on a cloud server and allow thousands of devices to send data to that application. The cloud infrastructure can provide significantly more computing power, memory, storage, and other resources than would normally be available on an individual device.
Cloud computing is therefore another form of off-device computing. The main difference from edge computing is the typical location of the computing resources.
On-Device
Device ─────────► Device Processor
Edge
Device ─────────► Nearby Edge Server
Cloud
Device ─────────► Remote Cloud Server
The important idea is that on-device computing uses the device's own resources, edge computing uses nearby computing resources, and cloud computing uses remote computing resources.
6. On-Device vs. Edge vs. Cloud Computing
On-device, edge, and cloud computing differ mainly in where the computation is performed.
In on-device computing, the device performs the computation using its own processor.
In edge computing, the device sends the data to a nearby computer, such as an edge server, which performs the computation.
In cloud computing, the device sends the data to a remote cloud server, where the computation is performed.
The three approaches can be represented as follows:
On-Device Computing
┌───────────────┐
│ Device │
│ │
│ Data → Process│
│ → Result│
└───────────────┘
Edge Computing
┌───────────┐ ┌───────────────┐
│ Device │──Data───►│ Edge Server │
│ │◄─Result──│ │
└───────────┘ └───────────────┘
Cloud Computing
┌───────────┐ ┌────────────────┐
│ Device │──Data───►│ Cloud Server │
│ │◄─Result──│ │
└───────────┘ └────────────────┘
The choice between these approaches depends on the requirements of the application.
On-device computing is useful when the device has sufficient resources and the computation needs to be performed locally. Edge computing is useful when more computing resources are required but the processing should remain close to the device. Cloud computing is useful when an application requires large-scale computing, storage, or other resources that are not practical to provide near every device.
Therefore, these approaches should not be considered as completely separate technologies. A single system can use all three.
For example, a robot may perform basic sensor processing on-device, send computationally intensive tasks to an edge server, and send selected data to the cloud for long-term storage and large-scale analysis.
7. Takeaway
The choice between on-device, edge, and cloud computing is ultimately a choice about where computation should take place.
On-device computing keeps processing within the device, edge computing moves it to a nearby computer, and cloud computing moves it to remote computing infrastructure.
In practice, systems may use one or more of these approaches depending on their computing requirements, network connectivity, and application constraints.
Understanding these three models provides the foundation for deciding where data should be processed in a distributed system.