Skip to content
Joshua N. Grant - Geospatial Systems Architect
Tags
sempervent/sempervent.github.io
Home
What's New
Tags
Professional Profile
Projects
Technical Documentation
Doctrine
Architecture Decisions
Best Practices
Deep Dives
Tutorials
Contact & Collaboration
Joshua N. Grant - Geospatial Systems Architect
sempervent/sempervent.github.io
Home
What's New
Tags
Professional Profile
Projects
Technical Documentation
Doctrine
Doctrine
Start Here — Architectural Compass
Reading Tracks
Decision Frameworks
Anti-Patterns
Philosophy
Systems Glossary
Diagrams
Diagrams
Diagram Style Guide
Architecture Decisions
Architecture Decisions
ADR-0001: Site Architecture
ADR-0002: MkDocs + Material
ADR-0003: Best Practices vs Tutorials
ADR-0004: Why Just for Fun Exists
ADR-0005: ESP32 Section Architecture
ADR-0006: Embedded Expansion (LoRa + Power)
ADR-0007: Deep Dives Section
ADR-0008: Expand Deep Dives Section
ADR-0009: Deep Dives Expansion
ADR-0010: Deep Dives Governance
ADR-0011: Deep Dives Expansion Phase II
ADR-0012: Deep Dives Scale Governance
ADR-0013: Deep Dives Curation Model
ADR-0014: Elevate Site to Systems Doctrine
ADR-0015: Standardize Diagrams on Mermaid
Best Practices
Best Practices
📌 Start Here
📌 Start Here
ADR and Technical Decision Governance
Configuration Management
System Resilience & Concurrency
IAM & RBAC Governance
Data
Data
Reproducible Data Pipelines
Metadata as Control Plane
Architecture
Architecture
Cost-Aware System Architecture
Geospatial
Geospatial
Geospatial System Architecture
Operations
Operations
Failure-Oriented System Design
Data Processing
Data Processing
Spark
Spark
When to Use Spark
Scaling Spark Clusters
Spark on Kubernetes
Spark Performance Tuning
Spark in Modern Architectures
🐍 Python Development
🐍 Python Development
Developer Experience (DX) as Infrastructure: Golden Paths, Tooling Ecosystems & Workflow Automation
Python Package
Typing in Python
Python Concurrency
Python Async Best Practices
Pytest Best Practices
API Development
FastAPI Geospatial
Web Performance Optimization
TUI Applications
🦀 Rust Development
🦀 Rust Development
Rust Development Environment
TUI Applications
🐹 Go Development
🐹 Go Development
Go Development Environment
TUI Applications
📊 R Development
📊 R Development
R Development Environment
🐳 Docker & Infrastructure
🐳 Docker & Infrastructure
Docker & Compose
Conda to Docker Migration
SBOMs, Trivy Scans, and Automated CVE Mitigation
Nginx Production
NGINX Best Practices
Ansible Inventory Management
Ansible Playbook Design
Ansible Security Hardening
Ansible Performance Optimization
Jinja Best Practices
Advanced Tmux Workflows
📝 Git & Version Control
📝 Git & Version Control
Git Production
Git Workflows & Collaboration
Modern GitFlow Best Practices
🗄️ Database & Data Management
🗄️ Database & Data Management
Cross-System Data Lineage, Inter-Service Metadata Contracts & Provenance Enforcement
Semantic Layer Engineering, Domain Models, and Knowledge Graph Alignment
AI-Ready, ML-Enabled Geospatial Knowledge Graph
Parquet
GeoParquet
Patroni PostgreSQL HA
Database Optimization
Database Migrations & Schema Evolution
GeoParquet Data Warehouses
AWS Serverless Geospatial
Lakes vs Lakehouses vs Warehouses
Data Lake Governance
Geospatial Data Engineering
Geospatial Benchmarking
🐘 PostgreSQL Development
🐘 PostgreSQL Development
Core & Design
Core & Design
Development Environment
Database Design
Data Types
Constraints & Validation
Transactions & Concurrency
Indexing Strategies
Security Best Practices
Performance & Operations
Performance & Operations
Performance Tuning
Monitoring & Observability
Backup & Recovery
Replication & High Availability
Maintenance & Vacuum
Scaling Strategies
Connection Pooling
Troubleshooting
Configuration Management
Advanced Features
Advanced Features
Extensions
JSON & JSONB
Full-Text Search
Partitioning
Time Series Data
Large Object Storage
Foreign Data Wrappers
PostGIS Best Practices
Integration & Deployment
Integration & Deployment
API Development
Event-Driven Architecture
Data Pipeline Integration
Cloud Integration
Containerization
Deployment Strategies
Data Engineering
ETL Pipeline Design
📊 Data Governance
📊 Data Governance
Metadata Standards, Schema Governance & Data Provenance
Data Validation and Contract Governance
Data Freshness, SLA/SLO Governance, and Pipeline Reliability Contracts
Data Retention, Archival Strategy, Lifecycle Governance & Cold Storage Patterns
Data Quality SLAs, Validation Layers, and Observability for Tabular, Geospatial, and ML Data
🤖 Machine Learning & AI
🤖 Machine Learning & AI
ML Systems Architecture: Feature Stores, Model Serving, Experiment Governance, and Cross-System Reproducibility
Prompting LLMs
ONNX Model Optimization
MCP + FastAPI Full Stack
Embeddings & Vector Databases
Vibe → Agentic LLMs
R Data Exploration
🏗️ Architecture & Design
🏗️ Architecture & Design
System-Wide Naming, Taxonomy, and Structural Vocabulary Governance
Cost-Aware Architecture & Resource-Efficiency Governance
Holistic Capacity Planning, Scaling Economics, and Workload Modeling
Multi-Region, Multi-Cluster Disaster Recovery, Failover Topologies, and Data Sovereignty
Cross-Environment Configuration Strategy and Multi-Cluster State Management
Cognitive Load Management and Developer Experience
Architectural Fitness Functions and Governance
Temporal Governance and Time Synchronization
Repository Standardization and Governance
Event-Driven Architecture
Streaming Architecture Patterns: SAGA, CQRS, and Outbox
API Governance, Backward Compatibility Rules, and Cross-Language Interface Stability
API Gateway Architecture
Multi-Cloud Federation & Portability Architecture
Cloud Architecture
Secrets Management
Testing & CI/CD Pipelines
Documentation
ADR and Technical Decision Governance
Caching & Performance Layers
Cache-Topology Architecture
Data Mesh Architecture
Service Decomposition Strategy
Polyglot Interoperability Design
Reference Architecture Diagrams
RDF/OWL Metadata Automation
Protocol Buffers with Python
🔧 Operations & Monitoring
🔧 Operations & Monitoring
Observability as Architecture: Unified Telemetry Models Across Clusters, Services, and Languages
Chaos Engineering, Fault Injection, and Reliability Validation
Operational Risk Modeling, Blast Radius Reduction & Failure Domain Architecture
Cross-Environment Configuration Drift Prevention, Promotion Workflows & Release Channels
Observability-Driven Development (ODD), Telemetry-First Coding Practices, and Preemptive Debugging Architecture
Operational Resilience and Incident Response
Performance Monitoring
System Resilience & Concurrency
Configuration Management
Cross-Environment Configuration Drift Detection & Prevention
Release Management, Change Governance, and Progressive Delivery
Structured Logging & Observability
Grafana, Prometheus, Loki, and Observability
Testing Best Practices
Secrets & Configuration Management
Grafana
🔒 Security
🔒 Security
End-to-End Secrets Management & Key Rotation
IAM & RBAC Governance
Secure-by-Design Lifecycle Architecture Across Polyglot Systems
Secure Computes, Sandboxing, and Multi-Tenant Isolation for Polyglot Systems
Cross-Domain Identity Federation, AuthZ/AuthN Architecture & Identity Propagation Models
Secret Supply Chains, Encryption Lifecycle Management & Cryptographic Rotation Strategy
⚡ Performance
⚡ Performance
End-to-End Caching Strategy
🧪 Testing
🧪 Testing
End-to-End Testing Strategy
🖼️ Diagrams
🖼️ Diagrams
Systems Diagramming Best Practices
SVG Workflow Generation
🎨 Creative & Fun
🎨 Creative & Fun
Time Hygiene (UTC, TZ, Clocks)
Idempotency & De-dup
Celery Tasks
LaTeX Workflows
YAML Recipe Format
🔌 Embedded Systems & ESP32
🔌 Embedded Systems & ESP32
Programming Architecture
Power Management & Deep Sleep
Hardware & Electrical Safety
Embedded Security & OTA
Sensor Integration
E-Ink Display Integration
MQTT Security
LoRa Best Practices (SX127x)
Safety Checklist (Printable)
ESP32-S3 and C3 Notes
🔋 Power Electronics & Embedded Hardware
🔋 Power Electronics & Embedded Hardware
Power Electronics for ESP32
🏠 Home Automation & MQTT
🏠 Home Automation & MQTT
Home Assistant Security
Deep Dives
Deep Dives
📦 Data Formats & Storage
📦 Data Formats & Storage
Parquet vs CSV vs ORC vs Avro
Geospatial File Format Choices
Polars vs Pandas for Geospatial Data
The Physics of Storage Systems
The Operational Geometry of Spatial Systems
🧩 Systems Design & Architecture
🧩 Systems Design & Architecture
Why Most Microservices Should Be Monoliths
Appropriate Use of Microservices
Distributed Systems and the Myth of Infinite Scale
Distributed Systems Architecture
Event-Driven Architecture
Raft Consensus Explained
Why Most Kubernetes Clusters Shouldn't Exist
When to Use a TUI, CLI, or WebApp
Blockchain vs Hashchain
Merkle Trees Explained
Proof of Work Explained
🔭 Operations & Reliability
🔭 Operations & Reliability
Observability vs Monitoring
The Economics of Observability
Designing Resilient Distributed Systems
🐳 Infrastructure & Automation
🐳 Infrastructure & Automation
Container Base Image Philosophy
IaC vs GitOps
The Human Cost of Automation
The Economics of GPU Infrastructure
Building a Bitcoin Mining Rig
Converting Bitcoin Mining to LLM Clusters
The Myth of Serverless Simplicity
🏗️ Data Systems & Architecture
🏗️ Data Systems & Architecture
Lakehouse vs Warehouse vs Database
DuckDB vs PostgreSQL vs Spark
Why Most Data Pipelines Fail
Why Most Data Lakes Become Data Swamps
Prefect vs Airflow
Metadata as Infrastructure
The Hidden Cost of Real-Time Systems
The End of the Data Warehouse?
The Hidden Cost of Metadata Debt
Why Most ML Systems Fail in Production
Why Spark Clusters Fail in Production
The Economics of Distributed Data Processing
Spark vs DuckDB vs Polars at Scale
The Myth of Infinite Data Scale
Why Most Data Lakes Become Data Swamps
The Metadata Crisis in Modern Data Platforms
Why Most Data Pipelines Are Operationally Fragile
📡 Embedded & Radio
📡 Embedded & Radio
LoRaWAN vs Raw LoRa
MQTT vs HTTP in IoT Systems
ESP32 vs Raspberry Pi
Tutorials
Tutorials
🚀 Quick Start
🚀 Quick Start
Creating MkDocs GitHub Site
Monitoring with Grafana & Prometheus
🐍 Python Development
🐍 Python Development
psycopg2 to psycopg 3 Migration
Ruff Check Ignore in pyproject.toml
Class-Based NiceGUI Pages and Integrations
Advanced NiceGUI Architecture
Distributed NiceGUI Architecture with Redis
R Shiny Geospatial App
Click CLI to FastAPI Conversion
WebSocket Chat with FastAPI
Glitch Observatory (JS)
Chaos Engineering with Kubernetes and Python
Building a Python TUI
🦀 Rust Development
🦀 Rust Development
Rust + CSR (Parse & Build from Parquet/DB)
Event-Sourcing in Rust
Building a Rust TUI
🐹 Go Development
🐹 Go Development
Building a Go TUI
🐳 Docker & Infrastructure
🐳 Docker & Infrastructure
Multi-Stage Docker (Conda → scratch)
Slim Geospatial + GPU Containers (GDAL)
Slimming GPU Docker Images
Slimming TensorFlow GPU Images
TensorFlow GPU Slim Images - Repository Skeleton
Compose Profiles Polyglot Stack
RKE2 on Raspberry Pi Farm
Building a 2×8 RKE2 Cluster with Rancher, PGO, and Prefect
ZFS Tank with OS on NVMe
Deploy SLURM with Ansible on Raspberry Pi Cluster
Harbor Container Registry Setup
Dask with Ansible (CPU + GPU)
🗄️ Database & Data Engineering
🗄️ Database & Data Engineering
PostGIS Geometry Indexing
PostGIS Raster Indexing
Raster–Vector Workflows
Alembic Migrations
PostgreSQL Pooling (PgBouncer + FastAPI)
Solr + Postgres JSONB Search
Auditing PostgreSQL with PgAudit and PgCron
parquet_s3_fdw with Local, MinIO, Vast, and AWS
Building a Postgres Lakehouse Image with pg_lake and parquet_s3_fdw
GeoParquet with Polars
Generating Dark OpenMapTiles for the Entire US at Zoom Level 12
Real-Time Data Processing
Kafka + TimescaleDB IoT Streaming
Go-Glue OSM → PostGIS → Tiles Pipeline
Apache Spark Mastery
Apache Iceberg Mastery
Pulsar → Flink → Pinot (Realtime OLAP) + Superset
H3 + Tile38 + NATS + DuckDB
H3 Raster to Hex
IPFS + SurrealDB + Meilisearch + NATS + Deno + Svelte
Graph vs Vector Databases
Geospatial Knowledge Graph
DuckDB Parquet Data Quality
🤖 Machine Learning & AI
🤖 Machine Learning & AI
MLflow API Experiments
Local LLM Deployments (Ollama, llama.cpp, vLLM, TGI)
ONNX Browser Inference
RAG with Ollama + Database
MCP ↔ MLflow Toolchain
Semantic ML Training
🔧 System Administration
🔧 System Administration
iPXE Multi-System Booting
Remote Dev with tmux & screen
FIFO Prefect Flow with Redis
AWK Unix Text Processing
🖼️ Diagrams
🖼️ Diagrams
Layered Systems Diagrams: Mermaid → SVG
Mermaid → SVG Workflow Pipeline
📊 Data Science & Visualization
📊 Data Science & Visualization
Jupyter Notebook Best Practices (Geospatial Edition)
Mermaid Diagrams in MkDocs
TikZ Diagrams in LaTeX
Generative Art in R
🛠️ Development Tools
🛠️ Development Tools
jq JSON Parsing Mastery
find_files for parquet_s3_fdw
Mosquitto + Python (MQTT Best Practices)
Python UDP Messaging
Python Modbus Device Communication
Mixing Tech with Go Glue
Tauri + rqlite + Syncthing
🎨 Just for Fun
🎨 Just for Fun
Terminal to GIF
Redis Streams + Web MIDI
PostGIS Rasters + WebGL Art
IoT + IPFS + GraphQL + Blender
MQTT + TimescaleDB + WebSockets + Three.js
Fastify + Kafka + ClickHouse + WASM + WebGPU
Gonzo Prometheus Exporter
Git Commit Weather Station
Selenium Grid (Docker) + Python
Martin + PostGIS Tiling
Managing People in Software Development
OSC + MQTT + Prometheus + SuperCollider
Fractal Art Explorer (JavaScript)
Pi-Based Sample Library Server
Go Auth Backend (scratch + Compose)
Recursive Cathedral Generator (Kotlin)
MIDI-Driven Particle Nebula (Kotlin)
Cellular Automata Garden (Kotlin)
Pi Infinite Art Frame (Kotlin)
🔌 Embedded Systems
🔌 Embedded Systems
ESP32 E-Ink Environmental Monitor
ESP32 RF Room Light Controller
ESP32 + MQTT + Home Assistant
Contact & Collaboration
Tags
¶
Browse all content by topic tag.
[TAGS]
Back to top