Edge computing can be stratified based on how far the computing node is from the originating devices or sensors. We consider three primary tiers in terms of distance: Micro Edge, Far Edge, and Near Edge. These tiers correspond to computing at the device itself, computing in close vicinity to devices (on-site or access network), and computing at intermediate regional nodes respectively. Together, the embedded and far edge constitute what the EU study calls the Cloud-to-Edge continuum in IoT, which is expected to handle the vast majority of IoT data processing by 2027.

The micro Edge – also known as the Embedded Edge or sometimes Tiny Edge – refers to computation within the end device itself or within a node very closed from the device.  In this tier, data is processed directly at the Edge defined as the nodes connected in a direct mode. Micro edge nodes are typically microcontroller-based or system-on-chip devices integrated into sensors, actuators, wearables, or appliances. They are characterized by extremely constrained resources: low-power MCUs (e.g. Arm Cortex-M class processors) with limited clock speed and memory, often running bare-metal or real-time operating systems. These devices perform local data processing such as simple analytics or AI inference on-device.

Embedded/Micro edge computing is common in scenarios requiring immediate, on-edge node decisions. For example, a wearable health monitor that analyses vital signs in real time, a smart camera performing basic image recognition on-device, an industrial sensor that preprocesses vibration data and sends out only anomaly alerts or on micro-edge nodes. In such cases, the micro-edge nodes handles tasks like filtering sensor noise, threshold detection, or running a TinyML model for event detection. This reduces raw data transmission and enables real-time responsiveness critical for IoT applications like healthcare, robotics, and autonomous systems.

A list of the benefits is as follows. Processing occurs locally with essentially zero network distance, enabling instantaneous response (e.g. emergency cutoff triggered by a sensor). Only processed or relevant information is transmitted, significantly cutting down network traffic and cloud storage costs. Embedded edge devices can continue functioning and making decisions even with unreliable connectivity, since they do not depend on constant cloud access. Data does not leave the device, which minimizes exposure. By eliminating continuous cloud transfer, the attack surface is reduced and sensitive raw data (e.g. audio/visual feeds) remains local.

There are some limitations: micro-edge nodes have constrained hardware. Many embedded edge devices run on battery or energy harvesting, so they must perform within tight power budgets. High computational load can quickly drain batteries or overheat the small form-factor devices. Maintenance & Updates: Managing a large fleet of tiny devices can be challenging. Firmware updates, security patches, and monitoring must be handled remotely, and static firmware builds are no longer acceptable in modern deployments (lifecycle automation is needed). Real-Time Programming Complexity: Achieving real-time performance on resource-constrained hardware often requires specialized programming (e.g. optimized C code or TinyML model compression), which can increase development complexity.

The term “MICRO” can be misleading, as it implies that embedded edge nodes necessarily have limited computing resources. In reality, the embedded part of the edge encompasses nodes with varying capacities, ranging from those integrated into autonomous vehicles that can run advanced AI and compute a digital twin of the vehicle, to extremely basic computing systems embedded in environmental sensors.

The Far Edge refers to edge computing infrastructure within the access network, sitting one hop away from the endpoints. Far edge nodes include IoT gateways, local servers, or base-station computing units. In industry terminology this encompasses Multi-Access Edge Computing (MEC) servers. Essentially, the far edge can be thought of as any type of datacenters between the micro-Edges and the core network. The far edge is physically far from the centralized cloud but near the originating devices, say 10 kilometers on the average, providing a middle layer of computing. For example a computing unit at a 5G cell tower.

Far edge infrastructure typically has moderate to high computing power, often much greater than embedded devices, but less than large cloud data centers. A far edge node might consist of one or a few server-class machines or specialized edge appliances. They often operate in challenging environments (heat, dust, limited space), so they may be compact and hardened. Far edge nodes are usually responsible for site-specific or location-specific processing. Importantly, they are deployed at network locations closest to end-users: for a telecom provider, the far edge might literally sit at the bottom of cell towers. It might reside in the building where sensors are deployed (factory, hospital, etc.). Far-edge computing is thus suited for applications that demand low latency and high bandwidth for localized data streams.

Far edge nodes host applications that need real-time to near real-time processing of local data or rapid content delivery. Examples include MEC for AR/VR and Gaming. Telecom operators deploy MEC servers at cell sites or regional hubs to run latency-sensitive services like augmented reality or cloud gaming. These far-edge MEC nodes can stream interactive content or perform inference for computer vision, supporting applications such as AR/VR, real-time video analytics, and autonomous driving assistance, which are cited as prime use cases for far edge computing. A city might use distributed far edge for utility sites to process video from traffic cameras or sensor data from smart grids locally. This yields faster incident response (e.g. adjusting traffic signals in real time) and reduces raw data sent over networks. In retail stores or branch offices, far-edge mini-datacenters can run inventory analytics, in-store customer behavior AI, or security systems on-site. These enterprise edge deployments (a subset of far edge) ensure that even if connectivity to cloud is lost, critical business processes continue locally.

The benefits of far Edge is the quite low Latency. By being geographically close to devices/users, far edge nodes can deliver response times of  few milliseconds. This is essential for interactive applications (robotics, vehicle-to-infrastructure communication, etc.) that cannot tolerate cloud latency. Far edge computing performs data aggregation and filtering near the source. A large volume of raw sensor data can be processed or summarized locally (fog processing), sending only relevant results to the cloud. This alleviates network backhaul load significantly. An IoT system with far-edge capabilities can continue operating in a self-contained manner during cloud outages or network disruptions. For example, a factory’s control system can failover to its on-site edge server if the cloud link goes down, improving reliability for critical operations.

We have also a certain number of limitations. While more powerful than embedded devices, far edge nodes are still limited in scale. They may only have a fraction of the computational resources of a cloud data center. This means they can become a bottleneck if asked to handle very large workloads or sudden surges (capacity planning is needed). Scaling out far edge infrastructure (adding more nodes) can be costly and logistically complex compared to spinning up cloud instances. Far edge deployments are distributed across many locations (cell towers, telco premises, etc.), which introduces challenges in management, orchestration, and physical maintenance. Ensuring security updates, monitoring performance, and managing software across hundreds of edge sites can be difficult without robust edge management platforms. Far edge equipment might be deployed in non-data-center environments (e.g. outdoor enclosures or shop floors) with constraints on power supply, cooling, and physical security. These conditions can limit the type of hardware that can be used and may impact reliability or performance. The edge ecosystem is still evolving, and far-edge solutions from different vendors might lack standardization. This can lead to integration issues, as noted by the need for industry standards to enable interoperability in edge platforms.

The Near Edge refers to computing infrastructure positioned between the far edge and the centralized cloud. These are typically regional, operator-level data centers that are closer to the end-users than traditional cloud regions, but not on the immediate premises of the devices. In practice, near-edge nodes reside in locations such as telecom central offices, Internet Service Provider facilities, or dedicated regional data centers serving a city or metropolitan area. They form part of the service provider edge (the network-edge). The near edge is a layer that hosts more generalized services or aggregated data processing for a broader area, complementing the highly localized focus of far edge nodes.

Near edge infrastructure often consists of larger-scale computing resources (multiple racks of servers or a small data center) with environment controls akin to cloud data centers. However, these facilities are geographically distributed closer to users compared to main cloud hubs – for example, a telco might have an edge data center in each major city. Near edge nodes have substantial compute and storage capacity, capable of running virtualized network functions, content caching, and IoT data aggregation platforms. Latency to end devices is higher than far edge (due to some network transit) but still markedly lower than reaching a distant cloud region; near-edge latency is often in the range of 10–30 milliseconds depending on distance.

Some typical use cases are as follows. Communication service providers use near-edge data centers to deploy network-centric applications and customer services. For instance, 5G networks leverage near-edge computing to host functions like packet core or video streaming caches closer to subscribers. Applications such as content delivery networks (CDNs) and online gaming platforms frequently run on near-edge servers to reduce lag for end-users. These near-edge nodes provide generic services (not specific to one site) that benefit from being closer to all users in a region, e.g. regional IoT data hubs or cloud gaming servers. In large-scale IoT deployments (smart cities, nationwide sensor networks), a near-edge facility can collect and process data from many far-edge sites. For example, a utility company might consolidate data from edge gateways across a region to a near-edge data center for deeper analytics or machine learning that requires more horsepower than on-site gateways can provide. Enterprises that cannot host heavy computing on-premises might utilize near-edge cloud nodes (offered by telco or cloud providers) for running AI models on IoT data. For example, video feeds from several retail stores could be sent to a nearby regional edge cloud for AI analytics (like footfall analysis across stores), achieving a balance between low latency and centralized insight. For vehicle-to-infrastructure (V2X) scenarios, near-edge computing can act as a coordination layer. Data from vehicles might be processed at a roadside unit (far edge) for immediate reflexes, but also forwarded to a city-level near-edge server that computes larger-scale situational awareness (traffic flow optimization, collision avoidance strategies in a wider area) with slightly higher latency tolerance.

Benefits of near edge nodes are: shorten the round-trip time relative to sending data to a distant cloud. While not as fast as on-prem far edge processing, they still enable near-real-time interactions for many applications (a few milliseconds to tens of milliseconds). This is sufficient for a broad class of responsive IoT services (e.g. interactive video or control systems that can tolerate slight delays). Because near-edge facilities are essentially mini data centers, they can host compute-intensive workloads that far edge devices might not handle. This allows offloading heavy analytics or AI inference from the far edge to the near edge when ultra-low latency isn’t required. The near edge can act as a second-tier aggregator, handling tasks like batch processing of IoT data, training of local AI models, or orchestrating resources across multiple far-edge sites. A near-edge data center can serve multiple customers or sites in a region, which is more efficient for certain services. Service providers can maintain these edge clouds and offer Edge-Computing-as-a-Service (e.g. an API for developers to deploy edge applications). This centralization at the network edge yields economies of scale (compared to every location having its own large compute) while still maintaining edge benefits. For example, a telco near-edge cloud might host localized instances of smart city services for multiple municipalities, rather than each city maintaining identical infrastructure. Finally, near edge nodes often run containerization and virtualization platforms similar to cloud. This makes it easier to extend cloud-native applications to the edge. They serve as a bridge between the fully decentralized far edges and the central cloud, aggregating data and syncing with core cloud systems. In practice, this can simplify data governance: raw data can be processed to an intermediate level at far edge, then forwarded to near edge for heavy lifting, and only distilled insights move to the central cloud.

There are several limitations. For the most time-critical functions, near-edge placement might still be too slow. Use cases requiring instantaneous response (sub-millisecond control loops or safety interventions) cannot rely on even a 10–20ms network trip. Thus, near edge cannot replace far edge for low latency needs; it complements it for moderately latency-sensitive tasks. Unlike on-prem embedded or far-edge solutions, near-edge computing often involves transmitting data off the premises (albeit to a nearby facility). This can raise privacy or compliance issues for sensitive data, similar to cloud concerns. Although data stays within a region, organizations may still be cautious about any external data transfer (e.g. hospitals might prefer on-site edge for patient data rather than a telco edge, unless strong guarantees are provided). Standing up regional edge data centers is capital-intensive. Operators must invest in distributed data center facilities with networking, power, and cooling. The model shifts some cost from the cloud provider to the network/service provider. If not enough workload is offloaded to the near edge, these sites could be underutilized. Balancing the deployment and operational costs with the actual demand is an ongoing challenge for the edge computing ecosystem. Finally, the near edge often involves multiple stakeholders (telecom operators, cloud providers offering “Outpost” or “Edge Zones”, third-party CDN providers, etc.). Managing service level agreements and technical integration across this edge continuum can be complex. For instance, ensuring seamless handoff of workloads between a hyperscaler cloud and a telco’s near-edge servers requires robust orchestration frameworks and business agreements.

It is worth noting that the distinction between “far” and “near” edge can sometimes blur. Some infrastructure can play either role depending on context (a telco central office might be a far edge for a telco’s internal network, but a near edge for a cloud provider’s perspective). In general, far edge hosts location-specific applications, whereas near edge tends to host more generic or aggregated services. Both are essential in the cloud-to-edge continuum, working in tandem to push computing as close as necessary to meet an application’s requirements.

Edge Computing Classification Table by Proximity

Another way to classify edge computing nodes is by their computational “thickness”, i.e. the intensity of computing capabilities and hardware resources of the node. An EU study segments edge computing hardware into Thin, Medium, and Thick categories based on the processing power of the semiconductors involved. This taxonomy is essentially an indicator of how much computing a given edge node can perform. It often correlates with device size and power consumption – from tiny microcontrollers to powerful edge servers. Below, we describe each category along with examples, use cases, and trade-offs.

“Thin edge” refers to edge nodes with minimal computing power – typically those built on microcontroller units (MCUs) or other low-power processors. These devices provide only modest processing capability (in the order of a few million to perhaps a billion operations per second). They are analogous to the “thin computing” semiconductor category highlighted by the EU, where the processor is highly constrained in performance but extremely efficient in power usage. Thin edge nodes often run simple tasks and may rely on event-driven operation or real-time processing of small data volumes.

Thin edge hardware includes 8-bit, 16-bit, or basic 32-bit MCUs, basic DSPs, and low-end SoCs. They commonly have a clock speed of tens to hundreds of MHz, RAM in the kilobytes to low megabytes, and very limited or no GPU/accelerator support. Because of their limited computing capacity, thin edge devices usually perform specific, narrowly-defined functions. They excel at tasks that require minimal computation per data point, such as reading a sensor and applying a threshold or simple filter. Many battery-operated IoT devices fall in this class. Connectivity for thin nodes might be via low-bandwidth networks (BLE, Zigbee, LPWAN, etc.) suitable for small data payloads.

Typical Use Cases for thin edge nodes are pervasive in IoT scenarios where power and cost must be minimized and the computational workload is light. Examples include: environmental sensors (temperature, humidity, air quality monitors) doing on-sensor averaging or threshold alerts; simple actuators like smart lights or switches that have basic control logic; wearable fitness trackers performing step counts and basic analytics locally; and single-purpose industrial controllers (e.g. a microcontroller in a motor that monitors speed and triggers an alarm if out of range). In all these cases, the device handles its function autonomously in real-time, but defers any heavy data processing or long-term analysis to higher layers if needed.

A first benefit is the ultra low power consumption. Thin edge devices are engineered for minimal energy use – often running on coin-cell batteries for years. For instance, whereas CPUs consume tens of watts and GPUs hundreds, microcontrollers operate in the milliwatt or microwatt range. This makes them ideal for pervasive deployment in IoT (sensors can be placed everywhere without major power concerns). MCUs and low-end chips are very inexpensive (often just a few dollars or less) and have a small footprint. Thin edge nodes thus enable large-scale IoT at low cost. Their simplicity also often translates to high reliability (fewer points of failure) and straightforward programming for basic tasks. Many thin devices run bare-metal or with a real-time operating system, allowing deterministic timing for control loops. They can react within microseconds or milliseconds to local events (sensor interrupts, etc.), which is important for real-time control systems (e.g. shutting off a machine when an anomaly is detected). With very limited software (often just embedded firmware) and minimal interfaces, thin edge nodes present a smaller attack surface. They also typically handle limited data scope. While not inherently secure, their simplicity can make it easier to harden specific functionality (though they may lack advanced security features of bigger systems).

However, thin nodes cannot perform heavy computations. They cannot run large machine learning models or process big data streams locally. Their memory constraints mean even moderate data buffering or complex algorithms are infeasible. This limits their role to simple, well-defined functions, often requiring them to send data elsewhere for intensive processing. IoT architects must assume thin devices cannot handle AI/ML or sophisticated analytics on their own (except in severely downscaled forms). Any intelligence beyond basic logic must either be pushed to slightly thicker edge devices or the cloud, or implemented via new techniques like TinyML (discussed later).

Thin edge devices usually perform a single task or a small set of tasks programmed into firmware. They lack the operating system and resources for robust multitasking. This means one device often corresponds to one function; achieving additional capabilities might require deploying additional devices or upgrading to a more capable class of edge node. Many thin edge nodes have limited debug or telemetry capabilities. Once deployed, it can be non-trivial to monitor their health or update them (though IoT device management solutions are improving this). If a thin device fails or behaves unexpectedly, diagnosing it remotely is harder compared to thicker edge devices that have more observability (logs, metrics, etc.).

Medium edge nodes represent the mid-tier of computing capability in the edge spectrum. They are more powerful than the thin MCU-based devices but not as advanced as the thick edge servers. This category typically includes devices built on System-on-Chips (SoCs) that integrate 32-bit or 64-bit processors, often with specialized co-processors or accelerators for AI, signal processing, or connectivity. Smart IoT devices with moderate AI capability, advanced smart sensors, or edge gateways with SoC processors fall into this group. The EU study identifies this segment as an opportunity for new medium computing semiconductors, such as SoCs based on advanced microcontrollers, smart sensor hubs, and compact multi-core processors.

Medium edge devices usually run on application-class processors (e.g. Arm Cortex-A series, MIPS or RISC-V cores, or low-end x86) possibly supplemented by NPUs (Neural Processing Units), DSPs, or GPUs of smaller scale. They often have an OS (embedded Linux, Android Things, or real-time OS with more features) and more memory (tens or hundreds of MB, sometimes 1–2 GB). This enables them to execute more complex software and even perform AI inference or data analytics locally, albeit within limits. Examples of medium edge hardware include: a smart camera that uses an on-board SoC to run a convolutional neural network on video frames; a Raspberry Pi or similar micro-compute board acting as an IoT hub; an automotive sensor module with an integrated AI chip for object recognition; or a smart sensor like Bosch’s Smart Sensor ISPU that embeds a microprocessor in the sensor package. These devices often strike a balance between performance and power consumption – they may run on a few watts of power, suitable for plugged-in or high-capacity battery operation.

Medium edge nodes are found in scenarios where moderate local intelligence is needed. They enable use cases such as edge AI appliances, e.g., a smart security camera that can detect faces or intrusions using an on-board AI model (something a thin device couldn’t do). Similarly, a medium-tier agricultural drone might process images locally to identify crop health indicators. Many IoT deployments use gateway devices that not only relay data but also perform data preprocessing or protocol translation. A medium edge gateway might run edge analytics – aggregating data from dozens of thin sensors and performing calculations or anomaly detection before sending summarized data upstream. Devices like smart thermostats, voice assistants, or AR/VR headsets often have medium-grade edge compute inside. They can perform speech recognition, simple neural network inference, or sensor fusion locally to improve responsiveness and privacy (for instance, processing voice triggers on-device before deciding to contact cloud). In Industry 4.0, we see PLCs and industrial PCs equipped with enough compute to run machine learning models (e.g. predictive maintenance algorithms) on the factory floor. These sit between the simplest sensors and the heavy compute clusters, providing a mid-layer of intelligence directly in machines or control cabinets.

On another side, there are sevral benefits.  Medium edge nodes significantly expand what can be done at the edge. They are capable of running moderate complexity models and algorithms, enabling local AI/ML for tasks like image classification, signal processing, or decision-making that previously required cloud resources. This leads to faster decisions and reduced cloud dependency for a large class of IoT applications (those with mid-range computing needs). With an OS and more resources, medium edge devices can support richer software stacks and even containerized applications. They can be updated OTA (over-the-air) with new algorithms or models, allowing deployment of new features or fixes. This makes them more adaptable over time compared to fixed-function thin devices. Medium nodes often hit a sweet spot for edge AI workloads, providing decent performance at power levels that can be sustained in the field (often a few watts to tens of watts). Advances in semiconductors (like specialized 22nm SoCs and chiplet architectures) are improving the performance-per-watt of this class, allowing these devices to take on tasks that were once the domain of much larger systems. In combination with thin sensors, medium edge nodes can operate autonomously at a local level. For instance, a medium edge device could coordinate a swarm of thin sensors – performing sensor fusion and local decision-making – without immediate cloud help. This improves reliability and real-time behavior for complex IoT systems (e.g. a medium edge controller in a self-driving car processes multiple sensor inputs to make split-second decisions, relying on cloud only for less time-sensitive data uploads).

Medium edges are still constrained vs. Thick Nodes. Medium edge devices, while capable, cannot match the raw performance of thick edge or cloud infrastructure. Large-scale analytics, training of machine learning models, or high-volume transaction processing remain out of reach. For example, a gateway might handle a few video streams with AI inference, but would struggle with dozens of HD streams simultaneously – those heavier tasks might still be offloaded to a data center (near edge or cloud) if needed. When medium nodes push their computations (e.g. running a deep neural net continuously), they can face thermal throttling or battery drain issues. They are often fanless and passively cooled, so sustained high utilization may cause overheating. Designers must carefully manage workloads or provide adequate cooling/power which can increase device cost. These devices are more complex and expensive than thin devices. They often require an OS, security management, and have more attack surface (since they run richer software). Ensuring security (patching Linux kernels, etc.) and reliability adds complexity. For cost-sensitive deployments (e.g. agricultural sensors), a medium edge device might be overkill when scaled to hundreds of nodes, so the use of medium nodes needs justification by the use case.

Medium edge computing – especially smart sensors with built-in AI – is a relatively newer area. Developers may face a learning curve to fully leverage on-device AI accelerators or to compress models to fit these devices. Toolchains like TinyML frameworks or vendor-specific SDKs are evolving. There can be fragmentation: one device might have a proprietary NPU requiring specific tools, making portability of solutions a challenge.

Thick edge nodes are the most powerful class of edge computing infrastructure, equipped with high-end processors and often resembling mini data centers. These are the edge devices with computing capabilities formerly limited to traditional data centers, including multi-core CPUs, GPUs, FPGAs, or dedicated AI accelerators. In terms of hardware intensity, thick edge nodes align with what the EU study calls “thick computing” semiconductors – the top-tier processors and memory solutions that can handle compute-intensive workloads. Thick edge nodes are typically deployed in scenarios where substantial data storage, analytics, or AI inference must occur at the edge (either due to latency, data volume, or privacy reasons). They often reside in controlled environments, which could be a localized data center (on-prem or in a regional facility) or even ruggedized servers in the field with significant power and cooling support.

A thick edge node might be an entire server (or cluster of servers) placed at an edge location. Hardware examples include an edge server with a multi-core x86/ARM CPU, equipped with one or more GPUs (like NVIDIA Jetson AGX or even full PCIe GPUs), or specialized AI accelerators (Google Edge TPU, Intel Movidius VPUs, FPGA cards, etc.). Memory is ample (several GB to tens of GB of RAM), and storage is sufficient for large datasets or caches. These systems often run full-fledged operating systems (Linux, Windows IoT) and can host virtual machines or containers akin to cloud servers. In network terms, they may sit at cell tower data centers, on-premises data centers, or the near edge facilities described earlier. In essence, thick edge nodes bring cloud-grade horsepower closer to the field.

Thick edge devices enable complex analytics on-site in real time. For example, in an oil and gas facility, a thick edge server could run advanced predictive analytics on high-volume sensor data (vibration, seismic readings) using machine learning models that are too large for smaller devices. In a smart city control center, a thick edge node might aggregate video feeds from hundreds of cameras and run advanced computer vision algorithms (traffic analysis, security threat detection) with minimal delay. Certain AI applications (e.g. high-resolution image recognition, natural language processing on speech, or multi-camera sensor fusion) require significant computation. Placing a GPU-equipped edge box on a factory floor can allow these heavy AI models to run locally. Autonomous robots or vehicles often carry onboard thick-edge computing units (e.g. NVIDIA DRIVE AGX in autonomous cars) to perform massive parallel computations necessary for perception and navigation, achieving real-time results without cloud dependence. When immense data volumes are generated at the edge, thick nodes can be used to locally process and reduce data. For instance, a gene sequencing machine in a remote lab might generate terabytes of data; a thick edge system can pre-process and filter this data, sending only condensed results to cloud, which is both bandwidth-efficient and protects raw sensitive data. Similarly, thick edge caches can store and serve data (videos, maps, machine learning models) to local users, much like a mini content server, improving performance for IoT devices retrieving large datasets or updates. In environments like hospitals or military operations, thick edge infrastructure can serve as an on-site cloud. They host applications that need to remain operational even if external connectivity is lost. For example, a hospital might have an edge computing rack that runs critical patient monitoring analytics or medical imaging processing on-site for reliability and data sovereignty. These are effectively edge clouds, with thick nodes ensuring continuity of service and immediate data availability.

Among benefits, we can quote the high performance at low latency. Thick edge nodes deliver data-center grade processing with edge-level latency. This combination makes new applications possible – for instance, interactive services that involve crunching large data in real-time (augmented reality with complex scene analysis, or cloud robotics coordinating multiple machines) can be deployed with user experiences nearly indistinguishable from on-device processing. The NVIDIA technical blog describes such thick edge scenarios as those capable of handling compute-intensive tasks/workloads (e.g., high-end CPUs, GPUs) at the edge data center. By keeping even very large computations local, organizations can satisfy data residency requirements. Thick edge nodes can store and process sensitive datasets entirely on-premises or within a controlled locale. Industries like healthcare, finance, or defense benefit from this – they get the analytical power of cloud-like systems without sending raw data off-site. This addresses privacy concerns and reduces exposure to cyberattacks during data transit. Instead of shipping terabytes of raw data to a central cloud, thick edge computing allows immediate crunching of that data where it’s generated. This drastically cuts down on backhaul bandwidth usage and yields faster insights. For time-sensitive decisions (machine failures, security breaches, etc.), having thick compute at the edge can mean the difference between catching an event in time or too late. According to projections, a large portion of data (in professional IoT, up to 81%) will be processed at the edge – including far and thick edge nodes – by 2027, precisely to meet such timeliness and bandwidth goals.

Having high-end compute on the edge opens opportunities for innovation tailored to local needs. Companies can deploy custom algorithms or third-party services at specific sites (as opposed to one-size-fits-all cloud services). For example, a remote mining site could run custom mineral analysis algorithms on an edge server specific to the local geology. This fosters a more distributed and flexible computing model, where edge sites can evolve independently and optimize for their unique context.

We also can deliver some limitations. Thick edge nodes are expensive and power-hungry. Deploying GPU-accelerated edge servers can cost tens of thousands of dollars and consume kilowatts of power. This is a major consideration for edge scenarios where power may be limited or expensive (remote locations running on generators/solar). The cost factor means thick nodes are used sparingly and usually only where absolutely necessary to justify the investment. The nodes often need data-center-like conditions (cooling, stable power, physical security). Not all edge locations can accommodate this. Setting up a thick edge node might require building a proper enclosure or micro-datacenter on-site. Maintenance also requires skilled personnel or remote management for what are essentially servers in the field. There is a risk that thick edge resources may be underutilized if the workload is overestimated or sporadic. Unlike cloud where resources are elastic, an on-site thick edge has fixed capacity – if not used continuously, it represents idle investment. Conversely, if demands spike beyond its capacity, it’s not trivial to scale up quickly (except by physically adding more hardware). This inflexibility needs careful capacity planning and possibly hybrid architectures (where cloud can assist if the edge cluster is maxed out). Running cloud-like workloads on the edge introduces complexity in software deployment. Applications must be containerized or otherwise packaged to run on these edge servers, and orchestrating updates or coordinating workloads between multiple thick edge sites and cloud is non-trivial. Edge orchestration platforms (Kubernetes at edge, etc.) are emerging, but maturity is lower than in centralized cloud environments. Organizations must tackle these complexities to fully leverage thick edge deployments.

Classification Table by Computing Capability (Thickness)

One of the most exciting trends is how advances in hardware and software are empowering the Micro-edge to perform tasks that used to require far larger systems. Continuous innovation in specialized chips and lightweight AI is effectively shrinking “thick” capabilities down into thin devices. This section highlights some key developments.

TinyML refers to machine learning techniques optimized to run on microcontrollers and small edge devices. By combining ultra-compact algorithms, model compression, and efficient runtime interpreters, TinyML allows even a $3 MCU to execute AI inference tasks that previously demanded a server. For instance, engineers have demonstrated keyword spotting, human activity recognition, and anomaly detection models running on devices with <256KB of RAM. The impact of TinyML is transformative: it enables real-time, localized decision-making without continuous cloud connectivity, fundamentally reducing latency and power use for IoT applications. TinyML frameworks (like TensorFlow Lite for Microcontrollers) and techniques (quantization, pruning) ensure that even resource-constrained devices can be “smart”. The benefit is clear: edge devices can now analyze sensor data on the fly instead of just logging and forwarding it, which aligns with the needs of latency-critical and privacy-sensitive IoT use cases.

Silicon vendors are increasingly building low-power AI accelerators into edge chips. These range from tiny neural processing units (NPUs) on microcontroller-class chips to efficient DSP extensions for ML. Examples include ARM’s Ethos-U microNPUs for Cortex-M, Qualcomm’s AI Engine on mobile SoCs, and various AI co-processors from startups. Such hardware accelerators are optimized for the math operations of ML (e.g. matrix multiplications, convolutions) and can dramatically speed up inference on device. Innovations like these enhance performance and efficiency of ML operations on edge devices by orders of magnitude, all while keeping power low. A practical result is that a medium edge device today might run a convolutional neural network as fast as a desktop CPU could a few years ago, and a microcontroller with an NPU can handle simple deep learning tasks at milliwatt power. This trend is closing the gap between what thin/medium nodes and thick nodes can do. For example, Intel’s Movidius and Google’s Edge TPU can plug into IoT gateways to add significant AI inferencing capability at the edge, and new MCUs from companies like NXP, STMicroelectronics, and Infineon now boast dedicated ML cores.

Beyond digital accelerators, neuromorphic chips are bringing brain-inspired computing to the edge. Neuromorphic designs (e.g. Intel Loihi, IBM TrueNorth, or startups like POLYN) use spiking neural network models or analog circuits to achieve massively parallel, ultra-low-power processing similar to a human brain’s efficiency. A recent example is a neuromorphic analog signal processor chip by POLYN, designed to sit next to sensors and process data in real-time without even needing a digital conversion. This TinyML chip can reduce raw sensor data by a factor of 1000× on the sensor node itself. Neuromorphic approaches excel at tasks like pattern recognition or anomaly detection with minuscule energy use. As these technologies mature, an embedded edge node might perform complex event detection continuously on a coin-cell battery, something infeasible with conventional digital logic. While still emerging, neuromorphic and analog AI offer a pathway to equip micro-edge devices with thick-edge-like cognitive abilities in an extremely efficient manner.

Advancements in semiconductor manufacturing and design are packing more capability into smaller chips ideal for edge. The development of System-on-Chip (SoC) and System-in-Package (SiP) solutions means that a single tiny module can now contain multi-core CPUs, a GPU/NPU, memory, and radios. For example, modern smart camera modules integrate an octa-core processor and AI accelerator in the size of a coin. The EU study notes that medium computing SoCs (32/64-bit MCU-based designs, <22nm process nodes, etc.) are poised to replace some thick computing needs. Additionally, process technology improvements and 3D chip stacking allow for more transistors (hence more computing power) in the power envelope of IoT devices. This miniaturization is aided by improved power management and the ability to turn on/off or scale frequency of parts of the chip as needed, so that high performance is available on demand without continuous high power draw. In summary, the hardware gap between a “device” and a “server” is narrowing: today’s high-end smartphone chip (which can be considered a medium-thickness edge device) outperforms some decade-old server processors, illustrating how much capability can reside at the edge.

On the software side, new algorithms make the most of limited hardware. Techniques like federated learning allow training AI models across many tiny devices without sending all data to cloud (preserving privacy). Edge-oriented algorithms can adapt model complexity based on available resources (dynamic model scaling). There are also containerization and virtualization solutions now optimized for small edge devices, enabling them to run multiple services in isolation (e.g. MicroVMs or lightweight Docker containers on IoT gateways). Cloud-native technologies are being re-tooled in projects like Eclipse Fog05 and K3s (lightweight Kubernetes) to orchestrate applications across micro and far edge devices seamlessly. These software innovations complement the hardware advances to fully unlock an intelligent edge: not only can the devices technically perform heavier tasks, but it is becoming easier for developers to deploy and manage complex workloads on a distributed fleet of edge nodes.

Thanks to these advances, functions that once had to run in a data center can now execute on a device the size of a coin or a deck of cards. For instance, imagine a surveillance system where previously video feeds were sent to a cloud server for facial recognition – now each camera (with an efficient SoC and TinyML model) can recognize faces or detect anomalies on its own, in real time, and only send alerts or summaries upstream. This not only slashes bandwidth use and latency, but also keeps video data local (improving privacy). Similarly, in healthcare IoT, wearable devices are starting to incorporate AI processors that analyze ECG or EEG signals on-device, alerting users to issues immediately without needing to transmit raw sensitive data. The combination of low-power AI, specialized chips, and edge-optimized software is thus blurring the line between what constitutes a “thin” or “thick” edge. The embedded micro-edge is becoming far more capable than it was just a few years ago, fundamentally expanding the scope of IoT applications that can be handled at the edge.

We are witnessing a paradigm shift in edge architecture: as edge computing technologies evolve, the embedded (micro) edge is poised to become the preferred architecture for most applications. The reasons are multifold and rooted in the advantages detailed above.

Computing on the device avoids the energy overhead of constant data transmission. Modern micro-edge devices leverage TinyML and efficient hardware to perform AI tasks in milliwatts. This significantly extends battery life and enables sustainable, scalable IoT deployments (sensors can run for years, and large fleets won’t overwhelm network energy usage). The cost per operation at the micro-edge is dropping rapidly, making it economically attractive to push more processing onto devices rather than incurring cloud compute costs. By eliminating network round-trip, embedded edge nodes provide instantaneous responsiveness. This is crucial for real-time control loops, safety systems, and interactive user experiences. As more computing muscle is packed into micro devices, fewer tasks are “off-limits” for on-device processing. From preventing industrial accidents by reacting in microseconds, to delivering smooth augmented reality experiences on smart glasses, the real-time benefits of embedded edge are unmatched by any other tier. Indeed, reducing latency is often not just about speed but enabling whole new functionalities (e.g. autonomous drones coordinating on the fly using onboard vision instead of relying on remote servers).

An embedded-first architecture dramatically cuts down on data flowing to the cloud. This alleviates network congestion and reduces cloud service costs. IoT deployments at scale (thousands or millions of devices) especially benefit – they become feasible only if most data is processed at the edge, due to both economic and technical constraints. The EU’s economic study on far edge computing underlines that edge-heavy approaches can lead to substantial cost reductions in industrial IoT operations. Enterprises are finding that an upfront investment in smarter edge devices pays off through lower connectivity and cloud bills over time.

Processing the majority of data on the end device presents an opportunity for manufacturers to operate independently of telecom operators. By significantly reducing the amount of data transmitted over networks and leveraging powerful peer-to-peer networks, it becomes feasible to deliver services to end users using a simple satellite connection.

Keeping data on the device by default provides intrinsic privacy benefits. In an era of heightened data protection requirements, an architecture that processes personal or sensitive data at the source is ideal for compliance. There is simply less risk of data breach or misuse when the data never leaves the device. Security is also enhanced since attack exposure is minimized; the device-to-cloud attack pathway is largely closed. Techniques like on-device encryption and secure enclaves further bolster embedded edge security. Users and consumers are more likely to trust IoT solutions that clearly limit data sharing, which gives an edge-centric design a competitive advantage.

Embedded edge architectures distribute intelligence, avoiding single points of failure. If each device can operate intelligently on its own, the overall system is more resilient to individual node failures or connectivity losses. Scaling out an IoT solution can be as straightforward as adding more devices (since each brings its own compute) rather than being bottlenecked by a central server limit. This decentralized model aligns with the evolving edge-cloud continuum, where cloud and edge collaborate, but with edge taking a larger role in the heavy lifting. It’s a future where cloud functions orchestrate or further analyze, but the first layer of computation – and often the most critical – happens on the edge.

The convergence of these factors makes a compelling case that the smallest edge (embedded devices) is increasingly capable of doing the job of the largest edge (regional data centers) for many scenarios. To be clear, this doesn’t eliminate the need for far or near edges and cloud entirely – rather, it optimizes the architecture so that each layer is used for what it is best at. Embedded edge nodes handle immediate, low-level intelligence; far edge nodes coordinate local groups of devices or provide additional compute for moderately heavy tasks; near edge nodes and cloud handle aggregated analytics, long-term storage, and cross-site insight. But with the rapid improvements in embedded computing, the balance is shifting toward doing more at the device level.

Industry trends and analyses support this direction. Gartner and other analysts have noted the shift of intelligence towards the edge as a key trend of the decade. By 2027, a large majority of data is expected to be processed outside of centralized clouds. As one commentary succinctly put it, “TinyML is transforming machine learning by enabling real-time intelligence on embedded devices. Its ability to process data efficiently at the edge makes it a game-changer for IoT applications, reducing latency, power consumption, and costs.” This encapsulates the essence of why the embedded edge is on the rise.

In conclusion, with devices becoming smarter, more powerful, and more independent, the optimal architecture for most IoT deployments is one that maximizes the use of embedded edge computing. Such an architecture reaps the benefits of efficiency, speed, and privacy, while relying on higher tiers (far/near edge, cloud) only as needed. Organizations designing IoT systems should therefore architect “from the edge inward,” first considering what can be done on-device before offloading to external nodes. The continuing advancements in edge hardware and software will only reinforce this approach. The future of IoT will be defined by intelligent devices at the periphery – a distributed network of smart endpoints that collectively achieve what previously required centralized, cloud-based architectures. Embracing this edge-centric paradigm will be key to unlocking IoT’s full potential in the coming years, enabling a new generation of applications that are fast, reliable, and respectful of users’ data and resource constraints.

Green Communications specializes in embedded edge computing and (one hop away) far edge computing. Our technology federates the computing and networking resources of end-devices, enabling digital services to be computed at the source and allowing devices to connect directly with each other. This creates a vast, meshed network of devices that can communicate and share services autonomously, independent of external infrastructure such as the Internet and cloud services, while maintaining interoperability. This innovative, crowdsourced digital infrastructure offers high capacity, low latency, innate resilience, and intrinsic privacy.

Decision Etudes & Conseil for European Commission. Study on the Economic Potential of Far Edge Computing in the Future Smart Internet of Things (Final Report). European Union, 2023.

Saro Velrajan. “Far Edge vs. Near Edge in Edge Computing.” Tech Ginkos Blog, 2019.

SUSE. The SUSE Guide to Edge Computing in a Cloud Native World, 2022.

IoT Analytics. “IoT edge computing – what it is and how it is becoming more intelligent.” IoT-Analytics.com, 2023.

NVIDIA. “Different Types of Edge Computing.” NVIDIA Technical Blog, Feb 16, 2022.

Orange. “Far Far Edge: The opportunities and challenges.” Hello Future Blog, Feb 2025.

Abdussalam Elhanashi et al. “Advancements in TinyML: Applications, Limitations, and Impact on IoT Devices.” Electronics, vol. 13, no. 17, 2024 (MDPI Open Access).

Ryan Beach. “The Future of IoT: How TinyML is Transforming Edge Intelligence.” Digital Pulse on LinkedIn, Aug 2023.

Planet Analog. “Neuromorphic analog signal processor aids TinyML.” PlanetAnalog.com, Oct 2022.

Fabio Bottacci. “The Role of Edge Computing in Industrial IoT: Real-Time Analytics and Decision-Making at the Edge.” LinkedIn Article, 2022.

EUCloudEdgeIoT Initiative. ALLPROS.eu Cloud-Edge-IoT Webinar Slides, Sept 2024.