Plausible Analytics is a production-grade, privacy-first web analytics platform implemented as a full-stack SaaS application. The backend is built with Elixir/Phoenix (LiveView, Ecto, Oban) and uses ClickHouse as the primary analytics data store alongside PostgreSQL for transactional metadata. The frontend is a React/TypeScript single-page application with Tailwind CSS, and a separate JavaScript tracker script is distributed via npm and self-hosted CDN. The system handles event ingestion, session management, real-time dashboards, goal/funnel tracking, billing/subscriptions via Paddle, team collaboration, SSO/SAML authentication, data imports from Google Analytics, and a public Plugins API. The codebase is dual-licensed (Community Edition and Enterprise Edition) with conditional compilation for EE features like consolidated views, customer support tools, and audit logging. The architecture is modular with clear contexts (stats, ingestion, billing, teams, auth, shields) and extensive use of Oban workers for background jobs, ConCache for distributed caching, and OpenTelemetry for observability. The repository demonstrates high engineering craftsmanship with comprehensive test coverage (ExUnit, Playwright, k6 load tests), well-structured abstractions (cache behaviour, rate limiter, write buffers, session balancer), and a clear separation of concerns between the Phoenix web layer, LiveView components, and the React dashboard.
Logflare is a production-grade, multi-tenant log management platform (now part of Supabase) built with Elixir/Phoenix. It ingests logs via HTTP, gRPC (OTLP), WebSockets, and platform-specific drains, processes them through a rule engine, and routes them to user-configured backends including BigQuery, ClickHouse, Postgres, S3, and many more. The architecture is a monolithic Elixir application with internal subsystems: an ETS-backed ingest queue for high troughput, Broadway pipelines for batched ingestion, a behaviour-driven adaptor system for pluggable storage backends, a custom query languagte (LQL) with a parser and dialect transformers, a distributed cache layer via Cachex and WAL busting, and Rust NIFs for performance-critial mapping and Arrow IPC. It includes a full web UI (Phoenix LiveView), a REST API (OpenAPI-documented), billing with Stripe, team management, and alerting. The codebase is largte (1700+ files) and mature (100+ database migrations), with extensive test coverage, benchmarks, and CI/CD pipelines. While predominantly an application, it also exhibits data engineerig aspects with its focus on high-volume log ingstion, schema evolution, and query optimization.
Blockscout is an open-source blockchain explorer for EVM-compatible chains, written in Elixir using the Phoenix framework. It indexes and serves on-chain data including blocks, transactions, internal transactions, token transfers, token balances, contract code, and more. The system is composed of four umbrella apps: `explorer` (database schemas, chain import pipeline, caching), `block_scout_web` (Phoenix web server with REST API v2, JSON-RPC, GraphQL, and real-time WebSocket channels), `indexer` (background fetchers that pull data from Ethereum nodes using JSON-RPC), and `ethereum_jsonrpc` (transport abstraction with chain-specific variants for Geth, Nethermind, Besu, etc.). The architecture is a monolith with clear separation of concerns, using PostgreSQL as the primary store, ETS/ConCache for caching, and Oban for async job processing. It supports multiple chain types (Ethereum, Optimism, Arbitrum, Celo, ZkSync, Scroll, and more) via compile-time and runtime configuration, with chain-specific data models and import pipelines. External dependencies include a PostgreSQL database, an Ethereum JSON-RPC endpoint, optional microservices for smart contract verification (Rust verifier, Sourcify), and third-party market data providers (CoinGecko, DefiLlama). The frontend is a single-page application built with jQuery and custom JavaScript, with real-time updates via Phoenix Channels. The codebase is well-structured with extensive use of Elixir behaviours (BufferedTask, Import.Runner, FillingMigration) and a sophisticated caching layer. It is actively maintained with frequent releases, thorough CI/CD, and a large community.
Bandit is a production-grade HTTP server library for Elixir, implementing HTTP/1 (RFC 9112), HTTP/2 (RFC 9113), and WebSocket (RFC 6455) protocols. It is built on the Thousand Island connection management library and serves as the default HTTP server for the Phoenix web framework (since version 1.7.11). The library is designed for correctness, security, and performance, achieving 100% conformance in the h2spec (HTTP/2) and Autobahn (WebSocket) test suites, while outperforming alternatives like Cowboy in benchmark comparisons. Architecturally, Bandit uses a protocol-sniffing initial handler that dispatches incoming connections to either an HTTP/1 or HTTP/2 handler based on the client preface. HTTP/2 connections follow a process-per-connection model with a separate stream process for each concurrent request, while HTTP/1 and WebSocket connections operate within a single process. The library exposes a small public API centered on the `Bandit` module, which validates options and delegates to Thousand Island. Internally, it defines clear abstractions such as the `Bandit.HTTPTransport` protocol for shared transport logic, a reusable `Bandit.Extractor` state machine for frame parsing, and telemetry spans for observability. Key features include support for HTTP/1 keepalive, HTTP/2 flow control and HPACK header compression, WebSocket permessage-deflate compression, content-encoding negotiation (gzip, deflate, zstd), Unix socket binding, and comprehensive error handling with clear RFC citations. The library is actively maintained with frequent releases addressing security vulnerabilities and edge cases, and includes extensive CI workflows for conformance testing, benchmarking, and regression prevention.
Firezone is a zero-trust network access platform providing secure remote access through VPN-like tunnels. The production system consists of a cloud-based management portal (Elixir/Phoenix), data-plane components (Rust gateways and relays), and native clients for macOS/iOS, Android, Windows, and Linux. The portal manages multi-tenant accounts, identity (OIDC, SAML, email OTP, X.509), access policies, device posture, and logs. It exposes a REST API (PortalAPI) for CRUD operations and WebSocket channels for real-time client/gateway connectivity. The Rust core (connlib) handles ICE/STUN/TURN connectivity, WireGuard tunnels, and eBPF-accelerated packet routing. PostgreSQL is used for persistence with logical replication for change data capture, Oban for background job processing, and Redis for caching/presence. External dependencies include identity providers (Entra, Okta, Google Workspace), device management systems (Intune, Defender, SentinelOne, etc.), log sinks (Splunk, Datadog, Elastic, S3), and billing (Stripe). The architecture separates the web admin interface (PortalWeb), REST API (PortalAPI), and internal ops (PortalOps) into distinct endpoints. Data-plane components (gateway, relay) communicate via WebSockets with the API to receive policy updates. Clients connect to relays using ICE/STUN/TURN. The system uses Phoenix PubSub for real-time updates and Postgres logical replication to propagate changes to connected clients and gateways. Key entry points: PortalWeb.Endpoint (admin UI), PortalAPI.Endpoint (REST/WebSocket for clients and gateways), PortalOps.Endpoint (ops dashboard). Rust binaries: firezone-gateway, firezone-relay, firezone-headless-client, firezone-gui-client. Mobile apps: Firezone iOS/macOS (Swift), Firezone Android (Kotlin).
Symphony is an autonomous AI agent orchestration service written in Elixir/Phoenix, designed to manage coding agents (like OpenAI's Codex) that resolve issues from project trackers. In production, it polls Linear, GitHub, GitLab, Jira, or Asana for new work, creates isolated per-issue workspaces, launches Codex agents with provider-native tools, manages retries and backoff, and provides live observability via a terminal dashboard and optional web UI. The architecture follows OTP best practices: a supervisor tree with GenServers for the orchestrator state machine, polling loop, status dashboard, and tracker adapters. Key entry points include the CLI (`SymphonyElixir.CLI.main`), the Phoenix web endpoint, and Mix tasks for code quality checks. Data flows are event-driven: poll tracker -> normalize to Issue struct -> dispatch via AgentRunner -> create workspace -> run Codex turns -> cleanup. The system is explicitly experimental ("engineering preview") but demonstrates strong engineering in its adapter pattern, configuration design, and test infrastructure.
Katbin is a pastebin service (pastebin/paste.rs-style) built on Cloudflare Workers with Hono, D1 (SQLite) via Drizzle ORM, and a Vite + React frontend styled with Tailwind CSS. It supports paste creation with syntax highlighting (highlight.js), markdown rendering, raw paste access, and configurable expiration. The service includes usage analytics with documented visitor limits, differentiated rate limiting (missing raw pastes are limited separately from existing ones), and admin routes that enforce authentication before executing any queries. Deployment is fully automated via GitHub Actions with separate production and staging environments, including D1 migration management through wrangler. The codebase demonstrates strong engineering practices: type-safe database access, careful analytics implementation with explicit visitor limit documentation, and security-conscious route design. The test suite covers API error handling, analytics edge cases, and rate limiting behavior.