Geospatial Telematics Developer

Geospatial and Telematics Developer

When to Use

• Design location-aware services—ingest, store, query, and serve positions, trajectories, and regions
• Implement CRS and projections—WGS84, local projected CRS, reprojection policy, bounds checks
• Work with vector and raster formats—GeoJSON, Shapefile, GeoTIFF, MVT; validation and simplification
• Build PostGIS / spatial SQL—geometry types, predicates, indexes, aggregates, and performance tuning
• Plan spatial indexing and tiling—GiST/BRIN, H3/S2 grids, vector tile pyramids, cache keys
• Integrate OGC map services—WMS, WFS, WMTS clients; layer metadata, bbox, and auth at integration level
• Process trajectories—dedupe, gap-fill policy, map matching hooks, stop detection, trip segmentation
• Implement geofencing—enter/exit/dwell, buffered predicates, timezone and schedule rules
• Ingest fleet telematics—GPS/GNSS fixes, NMEA parsing, device vs server timestamps, CAN-linked metadata
• Operate streams and batch ETL—Kafka/Kinesis-style pipelines, late data, idempotency, replay
• Address privacy and accuracy—precision reduction, retention, consent, jitter, and audit needs

When NOT to Use

• Pure OR routing / VRP / MIP without geospatial implementation (tiles, CRS, spatial DB, ingestion) → operations-research-algorithm-developer
• Multi-sensor perception fusion (LiDAR, radar, EKF/MOT, calibration) for autonomy → sensor-fusion-engineer
• WMS warehouse workflows—waves, pick paths, RF scanning, inventory allocation → wms-developer
• Snowflake/BigQuery marts, dbt, dimensional modeling without operational geo store → data-warehouse-engineer
• Generic backend, CRUD APIs, or cloud microservices without location domain → senior-software-engineer
• Simulation platform software—physics engines, SIL/HIL rigs, deterministic replay frameworks → simulation-software-engineer
• Robotics cell integration—PLC/AMR orchestration without fleet/geo pipeline ownership → robotics-automation-integration-engineer
• Legal privacy counsel or regulatory filings—route to legal/compliance; implement technical controls only

Related skills

Core Workflows

1. Scope and boundaries

Define geo/telematics footprint, consumers, retention, and handoffs.

See `references/geospatial_telematics_scope.md`.

2. Coordinates, projections, and formats

Pick CRS, validate geometries, and standardize exchange formats.

See `references/coordinates_projections_and_formats.md`.

3. Spatial databases and queries

Model schemas, indexes, predicates, and query plans in PostGIS or equivalent.

See `references/spatial_databases_and_queries.md`.

4. Telematics ingestion and quality

Parse device feeds, timestamp policy, quality flags, and batch/stream contracts.

See `references/telematics_ingestion_and_quality.md`.

5. Geofencing, tracking, and map matching

Rules engines, trajectory logic, and map-matching integration boundaries.

See `references/geofencing_tracking_and_map_matching.md`.

6. Serving APIs and operations

Tile/map APIs, OGC integration, monitoring, privacy controls, and runbooks.

See `references/serving_apis_and_operations.md`.

Outputs

• Location data model — entities, geometry columns, SRID, time columns, partition keys
• Ingestion contract — schema, idempotency keys, late-data policy, quality dimensions
• Spatial index and tiling plan — indexes, grid choice, zoom levels, cache invalidation
• Query and API spec — predicates, bbox rules, pagination, rate limits, error codes
• Geofence catalog — regions, triggers, debounce, timezone rules, audit trail
• Trajectory processing note — segmentation, map-matching vendor boundary, stop detection
• Privacy and retention matrix — precision, TTL, export controls, deletion hooks
• Operations runbook — lag alarms, replay procedure, CRS migration checklist

Principles

• Fix CRS and time first — wrong SRID or clock skew dominates downstream “algorithm” bugs
• Store raw plus derived — keep device fixes; derive matched/snapped layers with version pins
• Index for real queries — design GiST/grid indexes around bbox + time filters actually used
• Treat ingestion as idempotent — device sequence, dedupe keys, and replay-safe upserts
• Separate operational geo from analytics — OLTP/track store vs warehouse marts (data-warehouse-engineer)
• Document accuracy and privacy — horizontal accuracy, sampling rate, reduction, and lawful basis
• Integrate OGC; do not re-spec the standards — client patterns and failure modes, not full spec rewrite

When to load references

Coordinates, projections, and formats

Table of contents

1. CRS policy 2. Common CRS choices 3. Reprojection rules 4. Vector formats 5. Raster formats 6. Validation checklist

CRS policy

Never mix SRIDs in one geometry column. Always set ST_SetSRID on insert and validate bounds.

Common CRS choices

Reprojection rules

• Reproject once at a defined boundary (ingest, API response, or export)—not repeatedly in hot paths
• Use ST_Transform(geom, target_srid) in PostGIS; pin PROJ versions in production images
• For bbox queries across zones, prefer geography predicates or precomputed grid cells (H3/S2)
• Log source SRID on ingest when devices report local grids

Vector formats

GeoJSON conventions: RFC 7946, coordinates [longitude, latitude], right-hand rule for polygons.

Raster formats

Validation checklist

• [ ] SRID set on every geometry inserted
• [ ] ST_IsValid / ST_MakeValid policy documented for bad polygons
• [ ] Antimeridian and pole crossings handled for global fleets
• [ ] Precision documented (decimal places vs true GNSS accuracy)
• [ ] File imports include .prj or explicit CRS metadata
• [ ] Simplification tolerance scales with zoom level for tiles

Geofencing, tracking, and map matching

Table of contents

1. Geofencing models 2. Spatial predicates for fences 3. Event semantics 4. Trajectory processing 5. Map matching integration 6. Stop and trip detection

Geofencing models

Store fences in PostGIS with SRID documented; prefilter candidates with bbox or H3 before precise predicate.

Spatial predicates for fences

Debounce: require N consecutive inside samples or minimum dwell before ENTER to reduce GPS jitter false triggers.

Event semantics

Emit events with:

• asset_id, fence_id, event_type (ENTER/EXIT/DWELL)
• ts_event, position, confidence
• rule_version for reproducibility

Downstream consumers (billing, alerts, workflow) must tolerate at-least-once delivery—dedupe on natural keys.

Trajectory processing

Pipeline stages (conceptual):

1. Normalize — CRS, units, canonical fix schema 2. Filter — quality flags, impossible speed 3. Segment — trips on ignition/gap/stop rules 4. Enrich — geofence hits, timezone, jurisdiction 5. Match (optional) — snap to network; store vendor + graph version 6. Publish — API and warehouse export interfaces

Keep raw and derived layers; never overwrite raw fixes with snapped coordinates.

Map matching integration

Contract boundaries:

• Input: ordered fixes + timestamps + optional heading
• Output: matched polyline, edge IDs, confidence, distance on network
• Failure: return unmatched with reason; do not block raw ingest

Do not implement full routing graph maintenance inside generic app services—coordinate with operations-research-algorithm-developer for optimization on top of matched networks.

Stop and trip detection

Tune thresholds per asset class (truck vs trailer vs handheld). Document in configuration, not hard-coded constants.

Geospatial and telematics scope

Table of contents

1. Purpose 2. Terminology 3. In scope 4. Out of scope 5. Roles and RACI 6. Handoffs

Purpose

Define boundaries for building and integrating location-aware systems—from device/fix ingestion through spatial storage, processing, and map-facing APIs.

This skill covers implementation patterns, data contracts, and operations—not legal privacy advice, autonomy perception fusion, or warehouse operational workflows.

Terminology

In scope

Out of scope

Roles and RACI

Handoffs

Serving APIs and operations

Table of contents

1. API surfaces 2. Tile and map serving 3. OGC integration 4. Caching and CDN 5. Privacy and retention 6. Monitoring and runbooks

API surfaces

Contract essentials:

• Required time_start / time_end on history endpoints
• Max points per response; pagination cursors
• Explicit srid on geometry fields
• Rate limits per tenant and per asset subscription tier

Tile and map serving

Tile URL template example pattern: /{z}/{x}/{y}.mvt?layer=fences&tenant=

Invalidate caches on geofence publish and style version bump.

OGC integration

Integration-level guidance (not full spec):

Pin supported CRS list from GetCapabilities; fail fast on unsupported combinations.

Caching and CDN

Use ETag or version query params for cache busting after data migrations.

Privacy and retention

Coordinate with legal/compliance on lawful basis—implement technical controls only.

Monitoring and runbooks

Runbook snippets:

• CRS migration: add column → backfill → dual-write → cutover → drop old
• Replay day: pause derived jobs → replay Kafka topic with keys → rebuild trips
• Map vendor outage: serve raw tracks; flag matched=false in API

Hand off production incidents to site-reliability-engineer when SLOs and infra are involved.

Spatial databases and queries

Table of contents

1. Schema patterns 2. Geometry vs geography 3. Indexes 4. Common predicates 5. Query performance 6. Partitioning

Schema patterns

Track point (hot path):

-- asset_id, ts_utc, geom (Point, 4326), speed_mps, heading_deg,
-- accuracy_m, source_device_id, ingest_id

Geofence region:

-- fence_id, name, geom (Polygon, 4326), buffer_m, active, rules_json

Trip segment (derived):

-- trip_id, asset_id, start_ts, end_ts, geom (LineString, 4326), distance_m

Store raw fixes separately from matched/snapped geometries; version map-matching vendor and graph date.

Geometry vs geography

Example bbox filter (WGS84 points):

WHERE geom && ST_MakeEnvelope($minx, $miny, $maxx, $maxy, 4326)
  AND ST_Intersects(geom, ST_MakeEnvelope($minx, $miny, $maxx, $maxy, 4326))

Use && for index-friendly envelope prefilter before ST_Intersects.

Indexes

Create indexes after load on large migrations; ANALYZE after bulk ingest.

Common predicates

Query performance

• Avoid ST_Transform on every row in hot queries—materialize projected columns if needed
• Cap result counts; require time window + asset filter for track history APIs
• Use simplified geometries for low-zoom map responses
• Watch cardinality of DISTINCT spatial joins—pre-bin by H3 where possible

Partitioning

Document retention drop jobs per partition and legal hold exceptions.

Telematics ingestion and quality

Table of contents

1. Ingestion channels 2. NMEA and device payloads 3. Timestamps 4. Quality dimensions 5. Stream and batch patterns 6. CAN-linked metadata 7. Idempotency and replay

Ingestion channels

NMEA and device payloads

Common sentences (conceptual—validate against device spec):

Proprietary JSON often includes: lat, lon, speed, heading, accuracy, ignition, odometer, event_code.

Parse in a dedicated ingest worker; emit normalized canonical fix records to the spatial store.

Timestamps

Policies:

• Reject or flag fixes > N minutes in the future
• Define late arrival window (e.g. 24–72h) for stream processing
• Store all three when available: ts_device, ts_gnss, ts_ingest

Quality dimensions

Expose quality as columns or sidecar table—do not silently discard without audit.

Stream and batch patterns

device → ingest → validate → enrich (tenant, asset) → publish fix event → spatial writer

• Watermark on event time for windowed aggregations
• Dead-letter queue for schema violations
• Batch backfill replays with same idempotency keys as live path

CAN-linked metadata

Conceptual linkage only—implementation varies by OEM:

Do not claim safety-critical CAN semantics unless under automotive safety process.

Idempotency and replay

Monitor ingest lag (p50/p99), reject rate, and duplicate rate per device firmware version.