Build a Full-Stack Application with Scala 3 and the ZIO Stack
Just as Scala has transformed the way we build applications with functional programming, the ZIO stack is changing how we build strong, testable and provably correct APIs.
With a focus on functional Scala and a real world application, this course is a start-to-finish way to learn Full Stack Scala 3 with ZIO, Laminar and friends.
What will you build?
Together we will build the Rock the JVM Companies Board, a full stack online reviews platform with credit card checkout and AI integration. Users can create and manage their account, post and view reviews for Scala companies, and invite others to do the same.
We will build the application from scratch, using a ZIO-specific decoupled layered architecture on the backend, and functional-reactive programming architecture on the frontend with ScalaJS and Laminar.
The app includes many server-side bits including authentication, sending email, uploading images, charging credit cards and using an AI content generator. We have comprehensive test coverage in the backend, and we develop some core modules with test-driven development (TDD).
The frontend is built as a single-page application, organized for for scalability if you want to add new pages or functional components.
For a full list of topics covered, see below.
"Real-Life" means Real-LIVE
I want to put my code where my mouth is.
The application that you learn to build in this course is fully deployed and live here:
Yes, it's a real company review platform that I will personally use for my students at Rock the JVM - I don't know if it makes a good billion$$ startup, but you can proudly deploy the project in this course.
If you're a company and want to promote yourself to the Rock the JVM community, go ahead and use it!
To me, "real-life" means:
- it works with real email accounts
- it can charge money for buying product features
- it's complex enough to be a full-blown product
- it looks and works like a finished product
- you'll deploy it to a website with a domain you own (I'll do it on camera)
This isn't even a "project-based" course. You will learn to build a full-blown product that people can use and pay for. You can build your startup with what you learn in this course (maybe with a better business idea).
The Tech Stack
This course is built on ZIO. We use the following libraries:
✓ ZIO (core) for everything
✓ ZIO HTTP for server implementation
✓ Tapir for endpoint definitions, Swagger and frontend client
✓ Quill for type-safe database queries
✓ ZIO JSON for encoding/decoding HTTP payloads
✓ ZIO Config for, you know, configs
✓ ZIO Test for the test suite
✓ ZIO Test Containers for testing repositories and integration tests
✓ ZIO Logging for logs
On the frontend, we use
✓ Laminar. It's an amazing library for functional-reactive programming on the frontend with ScalaJS, and it's a breeze to use. We integrate it with ZIO in ScalaJS, into a mini-framework for the application.
We also use the following libraries and tools, wrapped in ZIO effects and ZIO layers:
✓ Stripe for credit card checkout
✓ GPT-4 for AI-generated content
✓ Flyway DB for schema migrations
✓ Auth0 JWT for creating and signing authentication tokens
✓ PostgreSQL for the database
✓ Java Mail for sending emails to people
What is ZIO?
ZIO is a Scala toolkit that allows us to write powerful, concurrent, and high-performance applications in Scala using pure functional programming.
Zay What?!
ZIO describes what it means to perform an "effect" in your code, which allows us to compose actions seamlessly.
On top of the main ZIO "effect" type, the ZIO library comes with powerful tools built on battle-tested practices and design patterns, so we can write more easily composable code.
Works the same on the frontend, too.
We use all the important ZIO libraries in this course.
How This Course Works
Who Is This Course For?
Scala developers who want to expand their Scala skills with a full-blown product as a full-stack application.
You should be comfortable writing any sort of Scala code, as we don't go over the Scala fundamentals. The beginner and advanced Scala courses focus on the language.
You should already be familiar with ZIO. We'll do a round of recap at the beginning of the course, but we'll focus more on the project.
The frontend is written in ScalaJS with Laminar. Any experience with them is nice, but 100% not needed.
To sum up, this course is for
- anyone looking for a complete end-to-end Scala project
- backend developers looking to go full-stack on Scala
- Scala developers looking to advance their skills and career
- anyone who wants to get better at Scala, full-stack architecture or functional programming
Not sure if it's for you? 100% money back if it's not a fit for you 💰
In any case, don't be scared. We'll build something great together.
Skills You'll Learn & Practice
In each video, we learn and implement a concept into our application. We'll sometimes use these repeatedly to solve new problems.
Because we build a full-stack Scala application, this course covers a ton. Here are some of the things you can expect to learn:
✓ REST APIs
✓ Authentication
✓ Authorization with JWTs
✓ Role-Based Authorization
✓ Sending Email
✓ Validating/Invalidating User Sessions
✓ User Input Sanitizing & validation
✓ Charging Credit Cards
✓ AI Integration
✓ Hosting and Transforming Images
✓ Complex Backend Filters
✓ Loading and Error states
✓ Functional Reactive Programming
✓ Routing
✓ Asynchronous Effects
✓ Webhooks
✓ Layering and Decoupling Modules
✓ Configuration
✓ Shared domain models
✓ Test-driven development
✓ Test Containers
✓ Building & Configuring for Dev, Staging and Prod
✓ Deployment With Custom Domains
100% Practical
This course is long so we waste no time. This screenshot shows you the code that we'll write together.
As with anything at Rock the JVM, this course is hands-on. We start by recapping the fundamentals of major ZIO libraries (ZIO, Quill, Tapir etc) and then we get started.
We'll build the project from scratch, starting from a blank directory and from first principles. As our code becomes more complex, we will modularize as necessary.
We will arrive at our layered architecture organically, without my imposing any style on you from the start. You may find it quite nice.
A chunk of the backend is written in test-driven development style. We also have chunks where we write tests after the implementation, so that you feel the difference first-hand. We also write some verticals bottom-up, some top-down, so that you know what it's like.
As for the frontend, we will add ScalaJS support from scratch, then we'll start scaffolding our app for scalability so you can easily add a new page, new stateful component or new endpoints.
We will also design our domain in a careful way so that the frontend and backend share the same definitions, eliminating nasty bugs due to schema mismatches.
Meet Rock the JVM
Daniel
I'm a software engineer and the founder of Rock the JVM. I started the Rock the JVM project out of love for Scala and the technologies it powers - they are all amazing tools and I want to share as much of my experience with them as I can.
As of December 2023, I've taught Scala and all major tools to 90000+ students at various levels and I've held live trainings for some of the top companies in the industry, including Adobe and Apple. I've also taught university students who now work at Google and Facebook (among others), I've held Hour of Code for 7-year-olds and I've taught more than 30000 kids to code (not in Scala 😆).
You're in good hands in this course. I'll guide you every step of the way, and our private community at Rock the JVM is full of passionate people just like you.
With special thanks to
Mark Rudolph, fellow Scala developer, for the initial scaffolded project that became the seed of this project-based course.
@fellownoodle for the amazing Rite of Passage banner.
What's Included
📹 30 hours of video
👩💻 6200 lines of code
💼 1 full-blown product
🤯 1 mind blown away (hopefully yours!)
Check out the lessons below - some are marked for free preview to get a sense of what we do in the course.
- Error Management (19:06)
- Users - Repository (11:07)
- Users - Service (28:31)
- JWT Tokens & Authorization (31:03)
- Configs (15:12)
- Users - Service Testing (28:58)
- Users - Endpoints (33:38)
- Integration Testing (32:29)
- Password Recovery (22:20)
- The OTP Flow (21:13)
- Sending Emails (29:44)
- A Round of Testing (18:56)
- Selectively Securing Endpoints (16:01)
- Frontend Setup (19:02)
- Laminar Crash Course (28:19)
- Routing and Header (25:43)
- Companies Page: Sharing Code between Frontend & Backend (24:36)
- Sending Backend Calls (17:16)
- Backend Calls - Infrastructure Mini-Framework (30:19)
- Filter Panel (19:47)
- Filter Panel, Part 2 - Backend (15:51)
- Filter Panel, Part 3 - Managing UI State (17:01)
- Filter Panel, Part 4 - Searching (36:51)
- Intro - Our Paid Product Feature (3:25)
- Backend Endpoints (27:59)
- The Service and Repository Layers (32:22)
- Sending Invites and Emails (20:32)
- Stripe - Overview (12:05)
- Creating Checkout Sessions (23:53)
- Stripe Webhooks and Activating Products (27:21)
- The Payment Flow on the Frontend (23:03)
- Sending Invites from the Profile Page (32:31)
- GPT-4 Integration: Infrastructure (24:24)
- GPT-4 Integration: The Service (14:43)
- GPT-4 Integration: Core (33:50)
- GPT-4 Integration: Frontend (25:31)
FAQ
1. Nah, the ____ library for JSON with ____ for frontend is much bettter!
That's not a question, but okay - I have spent close to a year evaluating many combinations of setups, libraries and styles for building a full-stack app with ZIO. I found this set to be the best fit. All the libraries inside are well supported, actively developed, and this is the stack I'd use to build a new app - heck, I did build one on camera.
This course isn't just teaching you how to hook together a few libs - you are learning to think and build full stack Scala 3 applications. The ideas behind this course transcend all libraries!
2. How about the Typelevel stack?
I have a course just as big for Typelevel, on a different app and with a totally different mode of thinking.
3. Is this course included with the membership?
All members will have a massive discount to this course under their account. So the benefits of being a member will only increase with time, regardless of what I create next.
4. Do you give a certificate?
Yep! You'll automatically get a certificate which you can export and use this to get reimbursed or land your dream Scala job.
The real reward, though, is when you make your own app with the ideas you learned in this course!
5. Can I expense this at my company?
For sure! After you enroll, you'll automatically get a tax-compliant receipt which you can use to reimburse this course with your employer.
6. What can I do with the code? Can I put it on GitHub?
It's your code, so go nuts! I just ask that you don't create your own course teaching with this app.
You can use the code in this course as
- a portfolio project to get a job
- a starting point to build your next trillion$ startup with Scala
- a quick prototype to impress your boss and convince them to use Scala
In any case, if you want to take something from the course, take the ideas, they're worth far more than the code.
7. Is the ZIO stack difficult?
It's not rocket science, but it's not trivial either. The learning curve is steep if you're doing it on your own. Materials are scarce. So I wanted to compress your learning time and hard-earned lessons into one comprehensive experience.
8. What if I'm not happy with the course?
If you're not 100% happy with the course, I want you to have your money back. It's a risk-free investment.
9. I'm just getting started with Scala. Can I take this course?
Short answer: probably not. Longer answer: we have some Scala starter code at the beginning of the course, but that won't replace the kind of experience we need for this course. I recommend you check out the Scala essentials and advanced courses first before coming back here.
10. Where did you get the banner art for the course?
The banner was created by the amazing @fellownoodle. She made the banner specifically for this Rite of Passage.