toreyheinz / 2026-GR-WebDevElixirTalk

2026 GR Web Dev Elixir Talk

Presenter Bio:

Torey Heinz is a full-stack developer at Vianet Management and founder of Shopflow, a software company serving small manufacturing businesses. Based in West Michigan, he brings over a decade of experience building web applications—primarily with Ruby on Rails and, more recently, Elixir and Phoenix. After 15+ years with Ruby on Rails, he caught the Elixir bug and hasn't looked back.

Presentation Title: Elixir in the Real World: A Practical Introduction

Curious about Elixir? This session offers an introduction to the language powering systems at Discord, Pinterest, and Pepsi. We'll start with the "why"—a brief history of Erlang, the BEAM virtual machine. Then we'll explore what makes Elixir uniquely powerful: pattern matching that transforms how you write functions, lightweight processes that make concurrency approachable, and fault tolerance baked into the foundation.

Then we’ll explore some real-world code examples: sending over half a million personalized marketing emails, managing TCP connection pools to Verisign's domain registry, and building internal admin tools that span multiple sites.

Proposed Scope & Sequence

Total time: ~45-50 min presentation + 10-15 min Q&A

Part 1: Why Elixir? (10-12 min)

Hook them with the "so what" before diving into syntax

1.1 The Origin Story (3 min)

• Erlang: Built by Ericsson in the 80s for telecom switches that couldn't go down
• The BEAM: A virtual machine designed for massive concurrency and fault tolerance
• Elixir: José Valim (Rails core team) brought modern syntax and tooling to the BEAM in 2012

1.2 Who's Using It (2 min)

• Discord: Scaled to millions of concurrent users
• Pinterest: Notification system
• Pepsi: Real-time systems
• The famous "2 million WebSocket connections on a single server" demo

1.3 Why It Matters for Web Apps (5 min)

• Your key point: Web apps are I/O bound—waiting on databases, APIs, user input
• Most languages: threads are expensive, blocking is painful
• Elixir: Lightweight processes (not OS threads) make concurrency trivial
• Real example: Vianet migrated from AWS to Render, moved services to Elixir → faster sites, fewer resources, $10k/month savings

Part 2: The Language (15-18 min)

Show what makes Elixir different—not a full tutorial, just the "aha" moments

2.1 Pattern Matching (6-8 min)

• Not assignment—it's matching
• Function heads: same function name, different clauses based on input shape
• Your story: "At first it didn't click, then I realized you can write incredibly clear code where each function clause handles one specific case"
• Quick code example: handling different API response shapes

2.2 Processes & Concurrency (5-6 min)

• Processes are cheap (can spin up millions)
• Message passing instead of shared state
• "Let it crash" philosophy—supervisors restart failed processes
• Quick visual: supervision tree concept

2.3 LiveView & Livebook (4-5 min)

• LiveView: Real-time UI without writing JavaScript
  • WebSocket connection (no HTTP overhead)
  • Client sends just the event + changed data
  • Server sends back only the HTML diff
  • Result: tiny payloads, instant updates
• Livebook: Interactive notebooks for Elixir (great for learning, demos, data exploration)

Part 3: Real-World Code (15-18 min)

This is where you prove the concepts with battle-tested examples

3.1 Email Marketing System (6-8 min)

• The challenge: 500k+ personalized emails
• Supervision tree with a rate limiter—how it works
• Concurrency: processing emails and webhooks efficiently
• Bonus: Wiring up TinyMCE with LiveView JavaScript hooks

3.2 Domain Registry Integration (4-5 min)

• Connecting to Verisign via TCP
• Connection pooling with the BEAM
• Why Elixir makes this cleaner than other approaches

3.3 Internal Admin App (4-5 min)

• Multi-site management
• LiveView for real-time admin dashboards
• How quickly you can build interactive tools

Wrap-up (2-3 min)

• Resources to get started (elixir-lang.org, Livebook, Phoenix docs)
• Your contact info / open to questions

Notes on Flow

The structure now follows your promo exactly:

1. Why → History, BEAM, companies using it
2. What makes it powerful → Pattern matching, processes, fault tolerance
3. Real-world examples → Email, Verisign, admin tools

Does this sequence feel right? A few questions:

1. Livebook demo? Are you planning to show Livebook live, or just mention it? A quick live demo could be a nice interactive moment.

2. Code depth: For the real-world examples, are you thinking actual code on screen, or more conceptual with diagrams? The supervision tree / rate limiter could go either way.

3. The $10k savings story—do you want that in the opener as a hook, or save it for later as proof?

What's working well:

• Three-part structure (Why → Language → Real World) is clean and builds logically
• Timing seems realistic for ~50 minutes
• The progression from theory to "aha moments" to production proof is strong

A few thoughts on the open questions in your notes:

1. Livebook demo — a live Livebook demo would be a great interactive break between Parts 2 and 3. You could show pattern matching and processes live instead of static slides, which doubles as "here's how you can try this tonight."
2. Code depth — for the GR Web Dev crowd (JS/Rails folks), actual code on screen will land better than diagrams. Keep snippets short and focused — one concept per slide. Side-by-side Elixir vs JS/Ruby could be powerful for the "aha" moments.
3. $10k savings — I'd tease it early in the hook ("we cut our infra bill by $10k/month") and then circle back with specifics in Part 3 as proof. Gives the audience a reason to pay attention through the language section.

What would you like to tackle first? Some options:

• Refine the outline — flesh out talking points, tighten timing, nail the narrative arc
• Build code examples — write the pattern matching, concurrency, and real-world snippets
• Start on slides — pick a format (Reveal.js, Markdown slides, Keynote, etc.) and start building
• All of the above — work through it sequentially

I do want to do all of the above, and work through it sequentially. Starting with refining the outline, fleshing out talking points, tighten timing, nail the narrative arc. To refine the outline we'll start a new outline.md file

A few thoughts on the open questions:

• Yes, let's use Livebook to demo/present the code examples
• Code depth: yes let's focus on actual code examples
• I think the $10k savings fits best in 1.3 Why It Matters for Web Apps

I agree these working well:

• Three-part structure (Why → Language → Real World) is clean and builds logically
• The progression from theory to "aha moments" to production proof is strong

Outline updates: During my intro I want make sure to give a shout out to my employer Vianet Management https://www.vianetmanagement.com/ who has allowed us to fully adopt Elixir

2.3 LiveView & Livebook

• Let's just focus on LiveView, we'll be using Livebook for demos, which should be enough to peak their interest

3.1 Email Marketing System (6-8 min)

• The challenge: 500k+ personalized emails
  • The challenge: Send 500k+ personalized emails through AWS, and if you exceed your rate limit AWS doesn't let you know, they just drop it.
  • Each email sent generates 3-4 requests
  • We don't want to take all day to send, it needs to be fast.
  • we don't want to double send

3.3 Internal Admin App

• one of the values here is that instead of building admin tools into the main app, you can keep the main app focused on delivering business value.

Scheduling 500k Jobs The Mailer Worker The Rate Limiter Why GenServer?

That's a lot of slides. What's your thinking — trim it down, reorder, or rework the focus? What do you want to keep vs cut?

Yes, we need to trim it down.

Keep:

1. Section divider — Internal Admin
2. The Philosophy — why a separate admin app
3. Multi-Database Architecture — application.ex with 5 repos (code)
4. LiveView: Async Charts — start_async + push_event (code)

Drop: 4. LiveView: Real-Time Admin Forms — assign_async from 3 DBs (code) 5. LiveView: Real-Time Presence — presence tracking (code) 7. The Flow — step-by-step of async chart loading

Let's rethink the "wrap-up" it should

• Rewrite "What we covered" based on the current slides.

• Highlight all the awesome things Elixir provides: This may take multiple slides

  • Supervision, GenServer, pattern matching, with chains, concurrency, LiveView. State lives in processes, not shared memory Errors are handled by design, not by hope Concurrency is the default, not an afterthought Real-time features come for free

• These aren't separate tools bolted together. They're all built into the language and framework.

Okay, let's finalize the presentation. Review each of these files for typos and consistency. Are we building a case for Elixir in a way that web developers will understand? - slides/01-intro.html - 02-the-language.livemd - slides/03-real-world.html

Let's add this screen shout after "The Core Function" it shows our EPP health page for OrbitFour