Tag
#elixir
52 articles
Supervision Trees for OSINT Pipelines: Let It Crash, Keep the Evidence
How Prismatic structures supervision trees so that a single flaky OSINT adapter never brings down a case. DynamicSupervisor, Task.Supervisor, and the one-for-one rule that saved production.
Task.async_stream Patterns: The One OSINT Concurrency Primitive You Actually Need
You don't need a job queue for 50 parallel OSINT lookups. You need Task.async_stream with the right timeout, the right max_concurrency, and `on_timeout: :kill_task`. Here's the recipe and the three gotchas.
From Bare Rescue to Typed Errors: How Prismatic Killed 6,000 Silent Failures
A `rescue _ -> :error` is a bug factory. It swallows the context that would have told you what went wrong. The ZERO doctrine banned them β here's what replaced them across 128 OSINT adapters.
Dialyzer, @spec, and the Shape of Correctness
Dialyzer is not a type checker. It's a proof assistant that accepts anything you can't prove wrong β and that is exactly what you want for a 94-app umbrella. Here's how Prismatic uses @spec and success typing without it becoming busywork.
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.
Ecto Changesets as the Validation Boundary: Trust Ends at the Schema
Validation scattered across controllers, contexts, and tests is how bad data reaches the database. Ecto changesets give you one boundary β enforce it and delete the duplicated checks.
Mix Releases for Zero-Surprise Deploys: What Ships Is What You Tested
A Mix release is a sealed artifact. Build it once, test it, ship the exact bytes to production. Here's the pipeline β and the three mistakes that make releases lie about what's running.
Feature Flags for Gradual Rollout: Ship the Code, Gate the Blast Radius
Deploy and release are different events. Feature flags let you ship code to production and enable it for 1% of users, then 10%, then everyone. Here's how Prismatic gates risky changes without branching hell.
Livebook for Intelligence Experiments: From Notebook to Production in One Step
A Livebook session connected to your running application is the fastest feedback loop Elixir has ever had. Here's how Prismatic uses it for ad-hoc DD queries, OSINT exploration, and model calibration without losing rigor.
Telemetry-First Observability: Events Before Dashboards
Dashboards built without a telemetry contract lie. Telemetry built without a consumer is overhead. Here's how Prismatic wires :telemetry events into a coherent observability story across 94 umbrella apps.
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.
Kompletni pruvodce 141 OSINT adaptery platformy Prismatic
Komplexni prehled vsech 141 OSINT zpravodajskych adapteru v platforme Prismatic -- ceske registry, globalni hrozby, instituce EU, sankce a dalsi.
The Complete Guide to Prismatic's 141 OSINT Adapters
A comprehensive overview of all 141 OSINT intelligence adapters in the Prismatic Platform β covering Czech registries, global threat intelligence, EU institutions, sanctions screening, and more.
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.
Building and Deploying Elixir Releases
Complete guide to Elixir releases covering mix release configuration, runtime.exs, Docker multi-stage builds, Fly.io deployment, and hot upgrade patterns.
Graph Databases in Elixir: KuzuDB Integration
Using KuzuDB as an embedded graph database for relationship data in Elixir. The prismatic_storage_kuzudb adapter, entity relationship modeling, Cypher query integration, and the DD relationship explorer.
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.
Concurrent Data Processing with Task, Flow, and async_stream
Practical patterns for concurrent data processing in Elixir using Task, Flow, and Task.async_stream for OSINT adapter queries, timeout management, and error isolation.
Structured Error Handling in Elixir: The ZERO Doctrine
A comprehensive guide to error handling strategies in Elixir covering ok/error tuples, with chains, specific rescue clauses, and why bare rescue is banned.
MENDEL: Genetic Algorithm System for Platform Evolution
How the MENDEL system uses genetic operators -- crossover, mutation, selection -- to evolve platform configurations, fitness evaluation, and generation tracking in Elixir.
Data Processing Pipelines with Broadway
Building robust data processing pipelines using Broadway for batching, rate limiting, backpressure, and acknowledger patterns in due diligence and OSINT workflows.
Full-Text Search with Meilisearch in an Elixir Platform
Integrating Meilisearch for full-text search: index management, faceted search, typo tolerance configuration, and glossary indexing for an intelligence platform.
Telemetry-Driven Development: Observability from Day One
How to build observable Elixir systems using :telemetry from the start, covering event design, span patterns, custom metrics, and the OTEL doctrine pillar.
Zero Trust in Elixir: The SEAL Doctrine
The SEAL doctrine enforces absolute security locks across the codebase. SQL injection, hardcoded secrets, Code.eval usage, and command injection are detected and blocked at both the pre-commit hook level and through AST-based static analysis.
REST API Auto-Discovery: From Elixir Modules to Endpoints
How Prismatic auto-discovers API endpoints by scanning Elixir modules, extracting @spec definitions, and generating a generic dispatch controller with type coercion.
GenServer Patterns for Production Systems
Battle-tested GenServer patterns covering state management, handle_continue, timeout strategies, Registry usage, and bottleneck avoidance in production Elixir systems.
Building Self-Healing OTP Supervision Trees
How Prismatic uses OTP supervision strategies, circuit breakers, and remediation registries to build systems that recover from failures automatically without human intervention.
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.
LiveView Performance Patterns for Complex Dashboards
Practical patterns for building high-performance Phoenix LiveView dashboards: defensive mounts, efficient assigns, PubSub-driven updates, and Chart.js integration with sub-150ms mount times.
ETS-Backed Registries: Sub-Millisecond Access in Elixir
ETS tables provide concurrent read access with sub-millisecond latency. The Prismatic Platform uses ETS for agent registries, OSINT tool catalogs, blog articles, and glossary terms with patterns you can apply to your own projects.
Building Type-Safe APIs in Elixir with Specs and Dialyzer
How to leverage @spec, @type, and Dialyzer to build robust type-safe API layers in Elixir, with practical examples from API response types and domain models.
OSINT at Scale: 157 Self-Registering Intelligence Adapters
The Prismatic OSINT framework uses Elixir metaprogramming to self-register 157 intelligence adapters at compile time. Each adapter declares its capabilities, input fields, and category, then appears automatically in the UI and API without any manual wiring.
Pre-Commit Security Gates: 9 Blocking Pillars for Code Quality
Implementing pre-commit hooks that enforce 9 blocking security and quality pillars: grep scanning for String.to_atom, hardcoded secrets, AST analysis mix tasks, and pillar-based enforcement architecture.
Zero Trust in Elixir: The SEAL Security Doctrine
Implementing the SEAL security doctrine in Elixir: parameterized Ecto queries, environment variable secrets management, Code.eval prevention, input validation boundaries, and OWASP Top 10 mapping.
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.
ETS-Backed Registries: Sub-Millisecond Data Access in Elixir
How Prismatic uses ETS tables as high-performance registries for agents, OSINT adapters, blog articles, and platform metrics. Patterns for compile-time loading, lazy initialization, and concurrent reads.
Threat Intelligence Feeds: Real-Time IOC Ingestion with GenServer
Building a threat intelligence feed aggregator in Elixir: integrating abuse.ch, AlienVault OTX, and MISP format feeds with IOC correlation, feed reliability scoring, and real-time GenServer ingestion.
Property-Based Testing in Elixir with StreamData
A practical guide to property-based testing using ExUnitProperties and StreamData, with real examples from validators, parsers, and encoders.
OpenCorporates Integration: Global Company Intelligence in Elixir
Integrating OpenCorporates API for global company search, jurisdiction mapping, officer lookups, filing analysis, and normalizing corporate data across 140+ jurisdictions in Elixir.
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.
DNS Intelligence and Enumeration: Passive DNS and Security Scoring in Elixir
Building DNS intelligence capabilities in Elixir: zone transfer detection, passive DNS analysis, DNSSEC validation, SPF/DKIM/DMARC security scoring, and DNS resolver patterns for OSINT platforms.
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
Phoenix PubSub at Scale: Topic Design and Fan-Out Patterns
Deep dive into Phoenix PubSub architecture for real-time event distribution at scale, covering topic design, fan-out patterns, message batching, and production conventions.
Sanctions Screening Automation: Fuzzy Name Matching and PEP Detection in Elixir
Automating sanctions screening with EU, OFAC, and HMT list processing, fuzzy name matching using Jaro-Winkler distance, PEP detection strategies, and false positive reduction in Elixir.
Elixir Development Standards v2.0: Complete File Excellence
The new v2.0 Elixir Development Standards mandate complete file excellence: every public function must be fully implemented, documented with @doc, covered by doctests, annotated with @spec, and benchmarked. Every directory requires a README.md.
WHOIS Domain Intelligence: Registrant Correlation and Historical Analysis
Deep dive into WHOIS-based intelligence gathering: registrant correlation across domains, historical lookups, privacy-protected domain handling, domain age scoring, and building a WHOIS parser in Elixir.
Certificate Transparency Monitoring: Real-Time Subdomain Discovery in Elixir
Implementing Certificate Transparency log monitoring in Elixir for continuous subdomain discovery, phishing detection from SAN fields, and real-time certificate stream processing with GenServer.
VirusTotal Intelligence Integration: Multi-Query Threat Analysis in Elixir
Building a VirusTotal adapter for threat intelligence: file hash lookups, URL scanning, IP reputation checks, domain reports, and efficient multi-query batching in Elixir.
Shodan Integration Guide: Building an OSINT Adapter in Elixir
Step-by-step guide to integrating Shodan's internet device search engine into an Elixir-based OSINT platform, covering API setup, banner parsing, service fingerprinting, CVE correlation, and rate limiting.
Introducing Prismatic SDK: Open Source Intelligence Development Kit
Prismatic SDK is now available as an open-source, MIT-licensed client library for TypeScript, Python, Elixir, and Go. Build intelligence applications with type-safe APIs, built-in retry logic, and streaming support.
Building OSINT Adapters with Elixir: A Practical Guide
Step-by-step guide to building production-grade OSINT adapters using Elixir, OTP supervision, and the Prismatic Plugin Kit. Covers rate limiting, error recovery, and confidence scoring.