Elixir & Phoenix Code Audit

GenServers, Ecto Queries, and LiveView State Gone Wrong

The most frequent problem: GenServers that shouldn’t be GenServers. Not everything needs a process. We find stateless computations wrapped in GenServers because someone thought “this is the Elixir way.” Each misplaced GenServer creates a serialization point. Work that could run across thousands of concurrent processes funnels through a single mailbox. Under load, that mailbox grows and response times spike.

Ecto query patterns are the second issue. N+1 queries hidden behind Repo.preload calls. Queries loading entire rows when one column is needed. Raw SQL fragments that bypass the planner. The BEAM handles concurrency well, but it can’t fix a database round-trip that shouldn’t exist.

LiveView problems show up under concurrency. Sockets carrying megabytes of assigns that should be derived at render time. PubSub broadcasts sending entire data structures instead of identifiers. Handle_event callbacks doing synchronous writes, blocking the socket process. These patterns work in development. They fail in production. Supervision trees are often flat - everything under one supervisor, no isolation between critical and non-critical processes. The fault tolerance OTP provides only works if your hierarchy reflects your failure domains.

Live System Profiling With Observer and Telemetry

We start with :observer and :recon to understand your running system. Process counts, message queue lengths, memory distribution, and ETS table sizes. A GenServer with 50,000 messages in its queue tells us more than reading its source code. This is a live system analysis, not just a code review.

We trace critical paths using :telemetry. From HTTP request to response, we measure every step - GenServer calls, database queries, external service waits. The trace data reveals the actual bottleneck, not the suspected one.

Ecto queries get EXPLAIN ANALYZE on production-like data volumes. We catch missing indexes, inefficient joins, and queries the planner handles differently at scale. For LiveView, we measure socket state size, handle_event execution time, and diff calculation cost. We identify assigns that should be temporary or streamed.

Correct Process Architecture and Real Fault Tolerance

Your system uses the BEAM correctly. GenServers manage state and coordination. Task.Supervisor handles concurrent work. Each process type matches its purpose, and the system scales horizontally without serialization bottlenecks.

Database performance improves because queries are optimized at the Ecto level. Preloads are batched, queries select only needed fields, and indexes match your patterns. LiveView scales to real user counts - socket state shrinks, diffs are smaller, and PubSub broadcasts target specific clients.

Your supervision tree reflects actual failure domains. When the payment provider goes down, only payment processes restart. The rest of the system keeps serving users. This isn’t theoretical fault tolerance - it’s practical resilience that prevents a Stripe outage from crashing your application.

Automated OTP Anti-Pattern Detection at Scale

We use AI-assisted analysis to scan for OTP anti-patterns at scale. This includes detecting GenServers that never use their state argument, handle_call implementations that should be handle_cast, and processes growing unbounded state without cleanup.

Our analysis maps the actual call graph between Phoenix contexts. Not the intended architecture - the real one. We generate dependency diagrams showing circular dependencies and coupling hotspots. This turns architectural discussions from opinions into observable facts.

Ecto query analysis identifies composition opportunities. Repeated WHERE clauses get flagged for extraction into reusable query functions. Fragments that could use Ecto’s query syntax get rewritten. We also generate test scenarios for untested GenServer state transitions, especially around error conditions and supervisor restarts. The BEAM’s “let it crash” philosophy only works if your supervision tree handles the crash correctly.