Tag
#architecture
20 articles
Umbrella Apps: When the Monolith Should Actually Split
Prismatic runs 94 umbrella apps. That number sounds insane until you realize what it isn't: 94 services, 94 deploys, or 94 teams. Here's the heuristic for when a module should become an app and when it should stay a module.
Polyglot Persistence: Four Storage Adapters Behind One API
PostgreSQL for truth, ETS for speed, Meilisearch for search, KuzuDB for relations. One storage trait behind all four. Here's the pattern that keeps the calling code boring.
Decision Envelopes: Why Sealed Intelligence Beats Mutable Maps
The DecisionEnvelope pattern turns ephemeral analysis into auditable evidence. How Prismatic uses sealed envelopes, epistemic/aleatoric uncertainty decomposition, and closed-loop reconciliation to make decisions you can defend.
Nabla Infinity: An Epistemic Engine for Intelligence Platforms
Most platforms track what they know. Prismatic also tracks what it doesn't β and why. Nabla Infinity is the epistemic engine that turns uncertainty into a first-class signal.
CQRS for DD Case State: When the Read Model Has to Lie (On Purpose)
A DD case has one write model and twenty read shapes β timeline, graph, risk score, audit log, compliance export. Forcing them all through the same Ecto query is how dashboards die. CQRS is the fix.
Decision Core: Closing the Loop Between Intelligence and Outcome
The decision core is the thinnest layer of Prismatic β and the one that matters most. Six pipeline stages, one sealed envelope, and a reconciliation loop that makes the whole platform learn from its own mistakes.
Building a Closed-Loop Decision Engine: No LLM Magic, Just Math
How we built deterministic decision infrastructure that learns from reality without black-box AI
Building an Intelligence Platform with Elixir: Why We Chose the BEAM
The technical rationale behind building Prismatic Platform on Elixir/OTP: fault tolerance for 128 OSINT adapters, concurrency for parallel intelligence gathering, and the BEAM's unique properties for real-time analysis.
From Monolith to 94 Apps: Our Migration Journey
The story of how Prismatic Platform evolved from a single Elixir application to a 94-app umbrella project. Decisions, mistakes, and lessons from 18 months of progressive decomposition.
1,110 Agent Definitions (~70 runtime): Building an AI Workforce
Inside Prismatic's agent ecosystem: 552 specialized agents covering OSINT, security, development, evolution, and operations. How they register, coordinate, and evolve.
Self-Evolving Architecture: How Prismatic Improves Itself
Inside Prismatic's auto-evolution system: genetic algorithms for code quality, SEADF framework for autonomous development, and how the platform has evolved through 19 generations.
Configuration Management in a Large Elixir Umbrella
Managing configuration across a 94-app umbrella: compile-time vs runtime config, environment variables, application-specific settings, and avoiding common pitfalls.
Mycelial Networks: Bio-Inspired Software Architecture
How the Prismatic Platform models software evolution on fungal mycelial networks. Pattern propagation, domain-scoped broadcasting, cross-domain synthesis, and the mycelial-mendel fusion that drives autonomous platform improvement.
Mycelial Network Architecture: Bio-Inspired System Design
Bio-inspired mycelial network topology for cross-domain signal propagation, nutrient routing, pattern extraction, and adaptive load distribution in a distributed platform.
Phoenix PubSub at Scale: Real-Time Event Architecture
Phoenix PubSub powers real-time features across the Prismatic Platform, from DD pipeline events to error pattern tracking. This article covers topic design, subscriber patterns, and handling backpressure at scale.
Umbrella Applications at Scale: Managing 94 Apps
The Prismatic Platform runs 94 applications in a single umbrella project. This article covers domain boundary design, dependency management, cross-app communication, and the tooling required to keep it all working.
The 18-Pillar Doctrine: Building Unbreakable Software Systems
The Prismatic Platform enforces quality through 18 interconnected pillars that cover architecture, security, performance, testing, and documentation. This article explains each pillar and how they work together to prevent defects.
Umbrella Architecture at Scale: Managing 94 OTP Applications
Lessons learned from building and maintaining a 94-app Elixir umbrella project. Covers dependency management, compilation strategies, testing patterns, and when umbrella architecture breaks down.
DD Pipeline Two-Phase Architecture: Client/Loader Pattern
Deep dive into Prismatic's two-phase due diligence pipeline architecture with concurrent fetching, entity processing, and PubSub streaming
The 18-Pillar Doctrine: Building Self-Enforcing Software Quality
How Prismatic Platform enforces quality through 18 complementary pillars covering architecture, testing, security, performance, and documentation -- all validated automatically at every commit.