ZIO Rite of Passage

ZIO Rite of Passage
English | Tutorial | Size: 4.52 GB

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

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.

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

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:

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
Asynchronous Effects
Layering and Decoupling Modules
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.

Buy Long-term Premium Accounts To Support Me & Max Speed



If any links die or problem unrar, send request to goo.gl/aUHSZc

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.