Your cart is empty.
Keep shopping
The Complete Elixir Phoenix LiveView Course - Real Estate
Hot & New
New
23 students
The Complete Elixir Phoenix LiveView Course - Real Estate
Build a real-time real estate platform with Phoenix LiveView, PubSub, Oban & Ecto. Multi-role auth, no SPA.
Created byAlpha Omondi Ogilo
Last updated 6/2026
English
What you'll learn
- Build a complete, production-ready multi-role SaaS with Elixir, Phoenix LiveView, and PostgreSQL — from authentication and onboarding through real-time chat to
- Implement real-time features in pure Phoenix — live notifications, typing indicators, presence tracking, broadcast fan-out — without React, Vue, or any external
- Design a custom database-backed RBAC system with roles, permissions, scoped grants, and route-level + per-resource authorization gates — instead of reaching for
- Run reliable background jobs with Oban — scheduled cron tasks, bulk email fan-out, per-recipient retries — entirely on PostgreSQL with no Redis or separate work
- Apply production-grade Ecto patterns: Ecto.Multi transactions, partial and composite indexes, cursor-based pagination, schemaless changesets, and soft-delete au
Explore related topics
Course content
10 sections • 78 lectures • 9h 13m total length
Requirements
- One year of web development experience in any backend language (Rails, Django, Node, Laravel, Spring, .NET — any of them are fine; this isn't an Elixir-only club).
- Basic SQL — you can write a SELECT, you understand what an index does, you've worked with at least one relational database before
- Comfort with the command line — running build commands, navigating directories, reading log output. We use Elixir's interactive shell (iex) extensively, but no prior Elixir is required.
- A computer running macOS or Linux is recommended (Ubuntu, Fedora, Arch — any modern distro works). Windows works through WSL2; I'll flag setup differences as they come up.
- PostgreSQL installed locally or via Docker — both setups are covered in the first lecture. Bring whichever you're more comfortable with; bring neither and we'll walk through it together.
Description
What if you could learn modern web development by building something real?
For three years, I lived in a 160-unit apartment complex run on a single WhatsApp account. Maintenance reports buried under marketplace ads. Technicians who ghosted calls. Neighbors complaining about each other in a group chat everyone reads — including the people they're complaining about. I eventually moved out, and built Proplex: the property management platform I wished my landlord had.
This course is the complete walkthrough of how it's built, end to end — every architectural decision explained on the way.
What You'll Build
A multi-tenant SaaS with three roles (tenants, technicians, admins) sharing one Phoenix LiveView app:
Invite-based tenant onboarding with atomic multi-step transactions
Issue tracking with state machines, soft delete, and an audit trail
Real-time chat per issue — typing indicators, emoji reactions, edit/delete, read receipts
Anonymous misconduct reporting with admin moderation and an escalation cascade
Custom dynamic role-based access control
In-app notification center + email broadcasts via Oban background jobs (no Redis required)
Marketing splash + role-aware personalized dashboard
What You'll Learn
Elixir + OTP fundamentals — pattern matching, processes, "let it crash" philosophy
Phoenix LiveView 1.1 — server-rendered HTML diffed over WebSocket; no separate frontend framework
Phoenix.PubSub + Phoenix.Presence — real-time fan-out and online tracking
Ecto deep dive — changesets, multi-step transactions, partial indexes, cursor pagination
Custom RBAC vs off-the-shelf auth — when to roll your own
Oban background jobs without Redis — bulk insert, scheduled cron, retry semantics
Tailwind v4 + daisyUI for fast, themed UI without tailwind.config.js
Production patterns — soft delete, audit trail, optimistic UI, schemaless changesets, structured logging
Who This Course Is For
Developers comfortable with any backend language, ready to apply Elixir to a real, multi-feature SaaS — not a tutorial example
Engineers from Rails / Django / Node curious about what LiveView changes day-to-day
Founders evaluating Phoenix as a single-deployment alternative to a JavaScript frontend + REST API stack
Anyone tired of courses that stop at "TODO list with auth"
Prerequisites
One year of web development experience in any backend language
Basic Elixir familiarity (or willingness to learn it alongside)
Comfort with SQL and the command line
macOS or Linux recommended (Windows works via WSL2)
What Makes This Course Different
Every architectural decision is explained, not just executed. When we add a partial index, you'll know why, not just that. When we choose Oban over Quantum, you'll understand the tradeoff. When we soft-delete instead of hard-delete, the reasoning is on the table. The codebase is heavily commented — and those comments explain the why, not the what.
By the end, you won't just have followed along. You'll have shipped a SaaS that could actually go to market, and the architectural instincts to build the next one on your own.
Enroll today and let's build something real.
Who this course is for:
- Backend developers from Rails, Django, Node, Spring, or .NET who want to see what real-time SaaS development looks like in pure Phoenix LiveView — without bolting on React, Redis, or a separate worker daemon
- Junior-to-mid Elixir developers who can build a basic Phoenix app but want to see how production-shaped patterns (custom RBAC, real-time chat, background jobs, audit trails) come together in one cohesive codebase
- Indie hackers and solo founders evaluating Phoenix as a single-deployment alternative to a JavaScript frontend + REST API stack — and who want a SaaS starter they can fork into their own product on day one.
- Self-taught developers and bootcamp grads with about a year of web dev experience who are tired of tutorials that stop at "TODO list with auth" and want to see what an actual shippable application looks like end to end