Government space programs generate terabytes of telemetry data per satellite per day. Processing this data in near-real-time — detecting anomalies, trending subsystem health, and delivering actionable status to operators — is a critical engineering challenge. Cloud architectures have fundamentally changed how this problem is solved.
The Satellite Telemetry Processing Challenge
Traditional satellite telemetry processing ran on on-premise mission operations infrastructure: custom hardware, proprietary databases, and tightly coupled software that was difficult to scale or modernize. Cloud architectures change the equation:
- Elastic ingestion: Handle telemetry bursts from multiple simultaneous contact windows
- Time-series at scale: Store and query billions of telemetry points efficiently
- Parallel processing: Apply multiple algorithms to the same telemetry stream without serialization
- Archive with access: Retain full telemetry history while keeping recent data immediately queryable
High-Level Architecture
Ground Station → AWS Ground Station / On-Premise → Kinesis Data Streams
↓
Lambda / Flink (real-time processing)
↓
┌────────────────────────────────────────────┐
│ Amazon Timestream (recent + hot data) │
│ Amazon S3 (archive + cold data) │
│ OpenSearch (anomaly search + dashboards) │
└────────────────────────────────────────────┘
↓
Mission Ops Dashboard / AlertsTelemetry Ingestion with Kinesis
import boto3
import json
from dataclasses import dataclass, asdict
from datetime import datetime, timezone
from typing import Iterator
@dataclass
class TelemetryFrame:
spacecraft_id: str
frame_count: int
timestamp: str # ISO 8601
apid: int # Application Process ID
data: dict
def publish_telemetry_frames(
frames: Iterator[TelemetryFrame],
stream_name: str,
region: str = 'us-gov-east-1'
) -> None:
"""
Publish telemetry frames to Kinesis Data Streams.
Uses batch puts for throughput efficiency.
"""
kinesis = boto3.client('kinesis', region_name=region)
batch: list[dict] = []
for frame in frames:
batch.append({
'Data': json.dumps(asdict(frame)).encode('utf-8'),
'PartitionKey': frame.spacecraft_id # Partition by spacecraft
})
if len(batch) >= 500: # Kinesis batch limit
kinesis.put_records(Records=batch, StreamName=stream_name)
batch = []
if batch:
kinesis.put_records(Records=batch, StreamName=stream_name)Time-Series Storage with Amazon Timestream
Amazon Timestream is purpose-built for telemetry time-series data with automatic tiering between in-memory (hours), magnetic (days-months), and S3 (years):
def write_telemetry_to_timestream(
frames: list[TelemetryFrame],
database: str,
table: str,
region: str = 'us-gov-east-1'
) -> None:
timestream = boto3.client('timestream-write', region_name=region)
records = []
for frame in frames:
# Each telemetry parameter becomes a measure
for param_name, param_value in frame.data.items():
if not isinstance(param_value, (int, float)):
continue
records.append({
'Dimensions': [
{'Name': 'spacecraft_id', 'Value': frame.spacecraft_id},
{'Name': 'apid', 'Value': str(frame.apid)}
],
'MeasureName': param_name,
'MeasureValue': str(param_value),
'MeasureValueType': 'DOUBLE',
'Time': str(int(datetime.fromisoformat(
frame.timestamp.replace('Z', '+00:00')
).timestamp() * 1000)),
'TimeUnit': 'MILLISECONDS'
})
# Write in batches of 100
for i in range(0, len(records), 100):
timestream.write_records(
DatabaseName=database,
TableName=table,
Records=records[i:i+100]
)Anomaly Detection Pipeline
import numpy as np
from scipy import stats
def detect_telemetry_anomalies(
parameter: str,
values: list[float],
timestamps: list[str],
z_score_threshold: float = 3.5
) -> list[dict]:
"""
Z-score based anomaly detection for telemetry parameters.
For operational use, combine with spacecraft-specific limit checking.
"""
if len(values) < 10:
return []
values_array = np.array(values)
z_scores = np.abs(stats.zscore(values_array))
anomalies = []
for i, (z, ts, val) in enumerate(zip(z_scores, timestamps, values)):
if z > z_score_threshold:
anomalies.append({
'parameter': parameter,
'timestamp': ts,
'value': val,
'z_score': float(z),
'severity': 'HIGH' if z > 5.0 else 'MEDIUM'
})
return anomaliesQuerying Telemetry Data
-- Amazon Timestream SQL: power subsystem health trend
SELECT
spacecraft_id,
bin(time, 1m) as time_bucket,
avg(measure_value::double) as avg_bus_voltage,
max(measure_value::double) as max_bus_voltage,
min(measure_value::double) as min_bus_voltage
FROM spacecraft_telemetry.power_subsystem
WHERE
spacecraft_id = 'SAT-001'
AND measure_name = 'bus_voltage'
AND time > ago(24h)
GROUP BY spacecraft_id, bin(time, 1m)
ORDER BY time_bucket DESCSee Rutagon's federal data analytics and MLOps guide and embedded systems defense requirements for related technical guidance.
Explore Rutagon's aerospace capabilities.
FAQ
What cloud regions are approved for government satellite telemetry data?
AWS GovCloud (US-East and US-West) is authorized for sensitive government data including telemetry from government spacecraft. Specific authorization depends on data classification — CUI, controlled technical data, and classified data have different authorization requirements. Work with your AO to confirm the approved cloud environment for your specific program.
What is the latency profile of cloud-based satellite telemetry processing?
AWS Kinesis ingestion typically adds 1–5 seconds of latency from telemetry reception to Lambda/Flink processing. For near-real-time anomaly detection with operator alerting, this is generally acceptable. For time-critical uplink command cycles, on-premise processing with cloud data replication is often used to ensure the required latency is met regardless of cloud connection quality.
How do you handle telemetry gaps from contact window boundaries?
Design your processing pipeline to handle out-of-order data (Kinesis and Flink both support this) and implement time-window-based analytics that detect data gaps explicitly. Alert on unexpected gaps in expected telemetry intervals. Store raw frames with reception timestamps separate from the telemetry-embedded timestamps to support replay and gap analysis.
Can AWS Ground Station replace on-premise ground station infrastructure?
AWS Ground Station can receive contacts from AWS-antenna ground stations, providing an alternative or supplement to owned ground infrastructure. For government programs, AWS Ground Station has government-accessible configurations. Whether it's appropriate depends on contact frequency requirements, frequency bands, regulatory licensing, and program security requirements.
What database is best for long-term satellite telemetry archive?
Amazon S3 with Parquet format provides the most cost-efficient long-term archive — data is queryable via Amazon Athena and Amazon S3 Select without loading into a database. For active analysis windows (recent months), Amazon Timestream's magnetic storage tier provides indexed time-series queries. A tiered approach (Timestream for recent + S3 Parquet for archive) balances cost and query performance.