
Install Elixir 1.19.5 and Phoenix 1.8.5, then verify versions in the terminal. Configure Postgres for data persistence with Docker in production and optional pgcli for terminal access.
Navigate to the working directory, generate a new phoenix app named proplex with mix phx new, install dependencies, and open the project in VS Code for the next lecture.
Navigate the mix Phoenix.new project structure, from build and assets to lib with proplex and proplex_web, and to config, env files, runtime.exs, and gitignore guidelines.
Remove default landing elements in a Phoenix Elixir app, customize the home page using layouts.app and tailwind, and streamline routing, flash messages, and styling.
Build and validate a user schema with a username field in a Phoenix Elixir app, implement a registration change set, username validation, and unique constraints while securing passwords.
Update the registration page to require username alongside email, implement live view form with debounced validation, and handle user registration with email confirmation and navigation flows.
Enable logout via the Phoenix Auth generator and implement reset password token verification by decoding a url safe token, hashing it, and querying the user with Ecto.
Define roles schema in authorization module using Ecto schema and changesets, mapping name, description, and property_id, with a many-to-many link to permissions via role_permissions and has many user roles.
Create the permissions schema and user role associations, fix folder misalignment, implement permission changesets with resource and action, and establish user_role with belongs to relations and unique constraints.
Define and assign roles to users within the authorization context, implementing getRoleByName and hasRole, creating userRole via repo.insert, and exposing listRoles and listPermissions.
Create the profiles table with a one-to-one relationship to users and a unique on user_id; add fields including first name, last name, gender, bio, avatar, and reputation defaulting to 100.
Build a profile show LiveView in a Phoenix LiveView app, rendering user data including avatar, display name, occupation, location, bio, reputation, rating, and reports, with formatting helpers.
Enable logged-in users to update their profile by building change sets for validation, applying edits, and saving via the repository, then wiring an authenticated live view route and permission checks.
Enhance the profile show live view by adding an edit button and displaying gender with occupation. Implement gender formatting and ownership checks, fix route order issue, and verify edits save.
Explain avatar upload handling in a Phoenix LiveView app, including live previews, resizing and compressing to JPEG, saving to uploads/avatars, and managing old avatars and errors.
Add a private helper to apply rate limiting on avatar saves, wrap the save flow with the rate check, and enforce a per-user one-hour quota with a friendly retry message.
Enforce rate limiting on the forgot password flow in a Phoenix LiveView app by capturing the client IP, checking limits, sending reset emails, and displaying retry guidance.
Configure Elixir's logger in config.exs, expand metadata to include event, user info, limiter, retry after, and auth and role data, then verify development logs.
Create apartment and tenancy schemas, add a one-to-many relationship from users to tenancies, define building name, unit number, and floor validations, with soft delete and trimming for live view guards.
Learn to implement start tenancy and end tenancy workflows in Elixir Phoenix LiveView, including pre-checks for archived apartments, audit logging, and active tenancy queries with preloaded apartment data.
Edit the router to add a live view route for my apartment, enforce authentication and apartments view own permission, then test tenancy creation via IEX and commit the change.
Build a Phoenix LiveView for real estate, mounting with a socket, fetching the active apartment for the current scope user, and enabling live form validation and issue reporting.
create an index live view to display a user’s reported issues, including an empty state and clickable issue cards with status and priority badges and assignee details.
master the mount function in a Phoenix LiveView to fetch an issue, handle reporter and admin viewers, and implement delete with permission checks and navigation.
Update root.html to conditionally display my assignments for users with view assigned and issues permissions, and seed roles to test admin, technician, and tenant workflows.
Extend the admin UI by building the apartments context with left joins to tenancy and user, apply filters for active and archived units, and configure admin live routing and permissions.
Create the admin index page to display every unit across all buildings with current occupants. Implement a filter bar and building dropdown to refine results by occupancy and building status.
Builds an admin live view for real estate listings using Elixir Phoenix LiveView, loading building names and apartments on mount with default filters, and implements interactive filtering and reset actions.
Add an admin apartments link in the admin ui by updating root.html.heex to route to /admin/apartments with proper authorization for the current user, enabling tenancy management and viewing apartment history.
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.