Building a Geopolitical Intelligence Dashboard with 530+ Data Sources: World Monitor's Architecture Breakdown

Hook

Most developers think Protocol Buffers require gRPC. World Monitor uses them as HTTP API contracts instead, generating type-safe REST endpoints from .proto files—295 definitions across 36 services, zero gRPC complexity.

Context

If you've ever tried building a situational awareness dashboard, you know the pain: feed formats are inconsistent, map libraries can't handle both performance and aesthetics, and AI inference costs spiral out of control at scale. Palantir solved this with millions in engineering investment and enterprise pricing. Grafana solves observability but requires you to build geospatial rendering from scratch.

World Monitor attacks this problem by treating dashboard variants as a compilation target rather than a runtime concern. Instead of one bloated application trying to serve news aggregation, finance tracking, and infrastructure monitoring through feature flags, it compiles separate deployments from a shared TypeScript codebase. Each variant—world, tech, finance, commodity, energy, even a 'happy news' feed—gets its own domain, feed configuration, and UI theme while sharing 95% of the underlying code. This is multi-tenant architecture turned inside out: build-time multiplexing that avoids the complexity tax of runtime switching.

Technical Insight

The architecture makes three unconventional bets that separate it from typical dashboard implementations.

Protocol Buffers as REST API Contracts

Most teams use Protocol Buffers with gRPC or abandon them entirely for JSON APIs. World Monitor uses sebuf annotations to map proto RPC definitions to HTTP endpoints, generating both OpenAPI specs and typed SDKs:

// news.proto
service NewsService {
  rpc GetLatestArticles(ArticleRequest) returns (ArticleResponse) {
    option (sebuf.http) = {
      post: "/v1/news/latest"
      body: "*"
    };
  }
}

message ArticleRequest {
  repeated string sources = 1;
  int32 limit = 2;
  string region = 3;
}

This generates REST endpoints (POST /v1/news/latest) with full TypeScript types on the client and runtime validation on the server. The payoff: you get gRPC-quality type safety and polyglot SDK generation without forcing web clients to deal with binary protocols or HTTP/2 streams. The 295 .proto definitions become the single source of truth for the entire API surface, preventing the drift that kills most TypeScript projects after a year.

Dual Rendering Engines with Transparent Switching

The UI runs two completely different map libraries simultaneously: globe.gl (Three.js-based 3D globe) for cinematic presentation and deck.gl (WebGL-optimized) for high-cardinality overlays. This sounds wasteful until you hit the performance wall.

globe.gl delivers the 'wow factor'—rotating Earth with arc animations for news events, perfect for engagement. But try rendering 10,000+ flight tracking points or infrastructure markers, and frame rates collapse. deck.gl handles massive point clouds trivially but looks utilitarian.

The state layer abstracts this entirely:

// Shared state interface
interface MapState {
  center: [number, number];
  zoom: number;
  points: GeoPoint[];
  activeRenderer: 'globe' | 'deck';
}

class MapOrchestrator {
  private globeRenderer: GlobeGL;
  private deckRenderer: DeckGL;
  
  sync(state: MapState) {
    if (state.points.length > 5000 || state.zoom > 6) {
      this.switchToDeck(state);
    } else {
      this.switchToGlobe(state);
    }
  }
}

The user never knows they're switching renderers—zoom in on a region dense with infrastructure, and deck.gl takes over seamlessly. Zoom out for the global view, and globe.gl's cinematic rendering returns. This pattern solves the 'performance vs. aesthetics' dilemma by refusing to choose.

Client-Side AI Inference Economics

Most 'AI-powered' dashboards burn money on OpenAI API calls for every user. World Monitor runs Transformers.js (TensorFlow.js successor) in browser WASM, executing sentiment analysis and entity extraction locally:

import { pipeline } from '@xenova/transformers';

const classifier = await pipeline(
  'sentiment-analysis',
  'Xenova/distilbert-base-uncased-finetuned-sst-2-english'
);

const articles = await fetchLatestNews();
const analyzed = await Promise.all(
  articles.map(async (article) => ({
    ...article,
    sentiment: await classifier(article.text)
  }))
);

This runs entirely in the browser—no backend, no API keys, zero marginal cost per user. The tradeoff: you're limited to distilled BERT models (~100M parameters) that fit in WASM, so 'AI synthesis' means keyword extraction and basic sentiment, not GPT-4 summaries. For users who want deeper analysis, the architecture falls back to Ollama (local) or Groq/OpenRouter (cloud) proxies. The economic model inverts the typical SaaS: free users cost nothing, power users pay for compute they control.

The MCP Server Deviation

World Monitor implements an MCP (Model Context Protocol) server, but breaks Anthropic's stdio specification in favor of HTTP streaming. Traditional MCP servers communicate via stdin/stdout, making them easy to spawn as subprocesses. World Monitor's MCP interface is pure HTTP:

app.post('/mcp/tools/analyze-region', async (req, res) => {
  const { region, timeframe } = req.body;
  
  res.setHeader('Content-Type', 'text/event-stream');
  
  for await (const event of analyzeRegion(region, timeframe)) {
    res.write(`data: ${JSON.stringify(event)}\n\n`);
  }
  
  res.end();
});

This trades MCP ecosystem compatibility (won't work with Claude Desktop or Zed without adapters) for web-native access—any agent that can POST to an endpoint and parse SSE streams can consume it. The bet: HTTP-native tooling matters more than stdio interop in a world where most AI applications run in browsers or cloud functions, not local terminals.

Gotcha

The 530+ upstream data source count is both the headline feature and the Achilles heel. There's no unified health monitoring—if Reuters changes their RSS feed format or a geopolitical API gets rate-limited, you experience silent degradation. The README mentions a 'freshness monitor' but provides no implementation or SLA guarantees. Production OSINT teams need circuit breakers, fallback sources, and alerting for stale data; World Monitor provides none of this out of the box.

AGPL-3.0 licensing creates procurement friction for commercial use. The docs say 'commercial licensing available' and claim SaaS deployment is 'allowed under AGPL,' but this creates legal uncertainty. AGPL's network use clause means if you embed this in a proprietary service, you might need to open-source your entire stack. There's no posted pricing for alternative licensing, no CLA (Contributor License Agreement), and no clear path for enterprises that need legal clarity. If you're a Fortune 500 building internal tools, your legal team will flag this immediately. The ephemeral architecture—Redis cache with no archive/export functionality—makes this unsuitable for compliance use cases where you need reproducible historical snapshots for audits.

Verdict

Use if: You're building custom OSINT infrastructure and need a reference implementation for multi-variant dashboard architecture, want to learn Protocol Buffers over HTTP patterns without gRPC overhead, or need a starting point for geopolitical monitoring that you'll fork and heavily customize. Security researchers prototyping threat intelligence tools and platform engineers exploring client-side AI inference will extract significant value from the codebase. Skip if: You need legally-clear commercial deployment (AGPL uncertainty kills procurement), require guaranteed data freshness SLAs and failure isolation for production use, need historical analysis and audit trails (ephemeral-by-design architecture can't support compliance workflows), or want true MCP ecosystem compatibility (the HTTP variant breaks stdio tooling). For vendor-supported situational awareness with uptime commitments, look at Palantir Foundry or commercial threat intel platforms like Dataminr. World Monitor's real contribution is proving you can build convincing geopolitical dashboards in TypeScript without enterprise Java backends—it's a teaching implementation and starting point, not a turn-key solution.