keepcalculator

06 Numbers and Powers

Cloud Architecture for Autonomous Systems: 3-Tier Design

Card No. 06·71165 · Updated · Standard formula, shown below

Raw ingest rate 48.83 MB/s
Raw data per month
120.7 TB
Result
Telemetry rate
10 Hz
You entered
Number of vehicles
100 vehicles
You entered
You enter
Telemetry rate, Number of vehicles, Data per sample
You get
Raw ingest rate, Raw data per month
Rounding
2 dp · 1 dp

This article explains a practical three-tier cloud architecture for autonomous systems, detailing the edge, data, and application layers. You will learn what each tier does, how they communicate, and how to choose the right components for your own deployment. The focus is on real-world design patterns, not vendor-specific marketing.

Formula

The calculator estimates the raw data ingestion rate and monthly storage volume for a fleet of autonomous vehicles. The first output is the ingest rate in megabytes per second (MB/s), and the second is the raw data accumulated over a 30-day month in terabytes (TB). The formula is:

Ingest rate (MB/s) = (Telemetry rate (Hz) × Number of vehicles × Data per sample (KB)) / 1024

Monthly data (TB) = (Ingest rate (MB/s) × 86,400 seconds/day × 30 days) / 1,048,576

Where:

  • Telemetry rate (Hz) – how many times per second each vehicle sends a data sample.
  • Number of vehicles – the size of your fleet.
  • Data per sample (KB) – the average size of each telemetry packet, including sensor readings, status flags, and metadata.
  • Ingest rate (MB/s) – the average data flow entering your cloud pipeline.
  • Monthly data (TB) – the raw, uncompressed volume before any filtering or processing.

Worked Example

Using the default values from the calculator: 10 Hz, 100 vehicles, and 50 KB per sample.

  1. Raw ingest rate = (10 × 100 × 50) / 1024 = 50,000 / 1024 ≈ 48.83 MB/s.
  2. Monthly raw data = (48.83 × 86,400 × 30) / 1,048,576 ≈ 126,562,560 / 1,048,576 ≈ 120.7 TB.

The calculator shows 48.83 MB/s and 120.7 TB, matching the manual calculation. This gives you a starting point for estimating cloud storage and network costs, though you will likely filter and compress data before long-term storage.

Why a Three-Tier Architecture?

Autonomous systems—whether self-driving cars, delivery drones, or industrial robots—generate enormous amounts of sensor data. A single vehicle can produce gigabytes per hour from cameras, LiDAR, radar, and inertial sensors. Sending all that raw data to a central cloud is expensive and introduces latency that can be dangerous for real-time decisions. A three-tier design splits the work into three logical layers:

  • Edge tier – runs on the vehicle or device itself, handling real-time control and immediate reactions.
  • Data tier – the cloud or on-premises storage and processing backbone for historical data, training, and analytics.
  • Application tier – the user-facing services, fleet management dashboards, and API endpoints that consume processed data.

This separation lets each tier be optimized independently: the edge for low latency, the data tier for scale and durability, and the application tier for usability and integration.

Edge Tier: Real-Time Decisions

The edge tier is the closest to the physical system. It includes the onboard computers, real-time operating systems, and the software that makes split-second decisions. In a self-driving car, the edge processes camera frames and LiDAR point clouds to detect obstacles, plan a path, and send control commands to the steering and brakes. This must happen in milliseconds, which is impossible if data has to travel to a distant data center.

The edge also performs initial data reduction. Instead of sending every raw frame, it might send only annotated objects, anomalies, or compressed video clips. This dramatically cuts bandwidth needs. For example, a drone might send a 10-second clip only when its camera detects a potential fault, rather than streaming continuously.

Edge hardware varies widely, from NVIDIA Jetson modules to custom FPGA boards. The key is that the edge tier is not just a dumb data source; it is an active participant that filters, prioritizes, and sometimes acts autonomously.

Data Tier: Storage and Processing

The data tier is the cloud core. It ingests the filtered data from the edge, stores it durably, and runs batch and stream processing jobs. This tier handles:

  • Data lakes – storing raw and processed data in object storage (like Amazon S3 or Azure Blob) in formats like Parquet or Avro.
  • Stream processing – using tools like Apache Kafka and Apache Flink to analyze data in near-real-time, detecting patterns or triggering alerts.
  • Batch analytics – running large-scale jobs (Spark, BigQuery) to train machine learning models, generate reports, or re-process historical data after an algorithm update.
  • Model training – using GPU clusters to improve perception and planning models based on the accumulated data.

The data tier is where you get the most value from the data. For example, a fleet of delivery robots can send edge-detected failures; the data tier aggregates these to identify a common battery issue and push a software patch to all vehicles.

Application Tier: Interfaces and Services

The application tier is what users, operators, and external systems interact with. It provides:

  • Fleet dashboards – live maps showing vehicle locations, status, and alerts.
  • APIs – REST or gRPC endpoints for third-party integrations, such as dispatching a robot to a new location.
  • Human override consoles – for remote operators to take control in emergencies (with a reliable network).
  • Configuration management – updating software and parameters across the fleet.

This tier is typically built with web frameworks (React, Django) and runs on managed services (Kubernetes, serverless functions). It consumes processed data from the data tier, not raw streams, to keep responses fast and simple.

How to Choose Your Cloud Stack

There is no single “best” cloud for autonomous systems; the right choice depends on your scale, latency needs, and existing expertise. Here are key factors:

  • Latency requirement – if your system needs sub-second response (e.g., remote teleoperation), you may need edge computing or a cloud region close to the vehicles.
  • Data volume – use the calculator above to estimate ingest rate; this determines network bandwidth and storage class (hot vs. cold).
  • Compliance – some industries require data residency within a specific country; choose a cloud provider with regions there.
  • Ecosystem – if your team already uses Kubernetes, pick a cloud that offers a managed Kubernetes service. If you rely on ROS (Robot Operating System), look for providers with ROS integrations.
  • Cost model – compare egress fees (data leaving the cloud) and storage retrieval costs, which can dominate for high-volume telemetry.

Many teams start with a single cloud provider and later adopt a multi-cloud approach to avoid lock-in, but that adds complexity. Start simple, then expand.

Common Problems and How to Avoid Them

Three-tier designs fail in predictable ways. Here are the most common pitfalls:

  • Underestimating bandwidth – sending too much raw data from the edge can saturate cellular links. Solution: aggressive filtering and compression at the edge.
  • Latency in the data tier – if your stream processing pipeline is slow, alerts arrive too late. Use in-memory processing and avoid writing to disk before analysis.
  • Data loss – network dropouts are inevitable. Design the edge to buffer data locally and retransmit when connectivity returns.
  • Security gaps – autonomous systems are critical infrastructure. Use mutual TLS for device-to-cloud communication, and never expose raw sensor streams to the internet.
  • Skewed data – if you train models only on data from one region, performance degrades elsewhere. Ensure your data tier samples diverse conditions.

Testing with simulated data and small pilot fleets before scaling helps catch these issues early.

Cost Considerations

Cloud costs for autonomous systems can explode if not managed. The main cost drivers are:

  • Network egress – moving data from the edge to the cloud and between cloud regions.
  • Storage – raw data is cheap to store but expensive to retrieve; use tiered storage (hot for recent data, cold for archives).
  • Compute – training models on GPUs is costly; reserve instances or use spot instances for non-critical jobs.
  • Data transfer within the cloud – avoid unnecessary copies between services.

A common practice is to set a data retention policy: keep raw data for 30 days, then downsample or delete. The calculator above helps you estimate the raw volume, but remember that processed data is often much smaller.

Safety and Reliability

Autonomous systems can cause physical harm, so the cloud architecture must support safety. Key principles:

  • Redundancy – critical services should run in multiple availability zones so a single failure doesn’t disable the fleet.
  • Graceful degradation – if the cloud connection is lost, the edge must be able to operate safely on its own, even if in a degraded mode.
  • Audit logging – record all decisions and commands for post-incident analysis.
  • Human oversight – always have a mechanism for a human to intervene, but ensure the system can handle a loss of the human link.

This is not just about uptime; it’s about designing for failure. A well-architected system fails safe, not catastrophically.

Alternatives to a Three-Tier Design

Not every autonomous system needs three tiers. Simpler alternatives include:

  • Two-tier (edge + cloud) – for small fleets or where the application tier is trivial, you can merge the data and application layers.
  • Fog computing – an intermediate layer (e.g., a local base station) that processes data before sending to the cloud, useful for low-latency regional decisions.
  • Fully edge-based – for fully autonomous systems that operate offline (e.g., a mining robot in a remote pit), all processing can be on the vehicle, with cloud only for occasional updates.

The three-tier design is a sweet spot for most commercial deployments, but always evaluate the actual requirements before committing.

Frequently Asked Questions

What is the difference between edge and fog computing?

Edge computing is on the device itself (the vehicle), while fog computing is a layer of local servers or gateways between the device and the cloud. Fog can aggregate data from multiple vehicles in a small area, reducing latency and bandwidth compared to sending everything to a distant data center.

How much data does a self-driving car produce?

Estimates vary, but a typical autonomous vehicle with multiple cameras and LiDAR can generate 1–5 GB per hour of raw sensor data. After compression and filtering, the transmitted amount may be only 10–20% of that, depending on the application.

Can I use a single cloud provider for all three tiers?

Yes, many teams do. Providers like AWS, Azure, and Google Cloud offer edge hardware, data storage, and application services. However, be aware of egress fees and the risk of vendor lock-in. A single provider simplifies management but limits flexibility.

How do I handle network disconnections?

Design the edge tier to buffer data locally and continue operating autonomously. When connectivity returns, the edge should sync the buffered data and any missed commands. For safety-critical functions, the edge must be able to operate indefinitely without cloud input.

What is the best way to secure device-to-cloud communication?

Use mutual TLS (mTLS) so both the device and the cloud authenticate each other. Store private keys in hardware security modules (HSMs) on the device, and rotate certificates regularly. Also encrypt data at rest in the cloud.

How often should I retrain models?

It depends on how fast your environment changes. For a fixed-route delivery robot, retraining every few months may suffice. For a self-driving car in varied urban environments, continuous learning with weekly or daily updates is common, but always validate new models in simulation before deployment.

Related

Formula used
in t | Telemetry rate | Hz | 10 | 1 | 100
in n | Number of vehicles | vehicles | 100 | 1 | 10000
in d | Data per sample | KB | 50 | 1 | 10000
out ingest | Raw ingest rate | MB/s | (t * n * d) / 1024 | 2
out monthly | Raw data per month | TB | (ingest * 86400 * 30) / 1024 / 1024 | 1

Each line is one input (in, sel, list) or one result (out: label, unit, formula, decimals). How the calculators work

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →