Tag
#elixir
45 articles
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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.