Build a Full-Stack Application with Scala 3 and the Typelevel Stack

Just as Scala has transformed the way we build applications with functional programming, the Typelevel 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 Cats, Cats Effect and friends.

Join me as I show you how to build a full stack jobs platform with the latest evolution of Scala and functional libraries.

What will you build?

Together we will build the Rock the JVM Jobs Board, a full stack online jobs platform with credit card integration. Users can create and manage their account, post and view jobs, and apply for them.

We will build the application from scratch, using a decoupled layered architecture on the backend, and an Elm-like architecture on the frontend with ScalaJS.

The app includes many server-side bits including authentication, permissions, sending email, uploading images, and charging credit cards. We have almost complete 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 jobs platform that I will personally use for my students at Rock the JVM!

If you're a company and want to promote your jobs to the Rock the JVM community, go ahead and use it!

And before you ask: yes, I'll teach you to do EVERYTHING from an empty dir to deploying on your own domain.

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.

The Tech Stack


The functional programming library for Scala. We will use it to make our code modular, expressed in terms of capabilities.

Cats Effect

The Scala library that allows us to write composable and high-performance applications with pure functional programming.

Every action we perform is built with Cats Effect.


The Typelevel library that allows us to work with databases, using type-safe queries. We will use PostgreSQL as an actual database.


With this Typelevel library we'll build our REST APIs with JSON payloads, automatic validation, incremental content loading with pagination etc., as well as manage authentication, authorization with JWTs and role-based access control.


A lightweight Scala 3 library for single-page applications in a purely functional way, Elm-style. While not "officially" a Typelevel project, it is based on Cats Effect and FS2 to manage application state. Our entire frontend is built with Tyrian:

  • routing
  • authentication flow
  • checkout
  • error/success UI state
  • fetching data from backend

Honorable Mentions

  • PureConfig for configuration
  • FS2 for incremental loading on the backend
  • FS2 for SPA history management on the frontend
  • TSec for JWT authorization and RBAC
  • Circe for JSON
  • Log4Cats for purely-functional logging
  • ScalaTest with TestContainers wrapped in Cats Effect

What is Typelevel?

Typelevel is a set of Scala libraries for building robust, scalable and high-performance applications.

Say what?

The foundation for Typelevel is pure functional programming and Scala's unmatched type system. With these tools, we can let the Scala compiler work in our favor, so we can write more modular code and in the end become more productive and happier as developers.

We will use all major Typelevel tools and 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 Cats and Cats Effect. 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 Tyrian. 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:



 Authorization with JWTs

 Role-Based Access Control

 Sending Email

 Validating/Invalidating User Sessions

 User Input Sanitizing & validation

 Charging Credit Cards

 Hosting and Transforming Images

 Incremental Loading and Pagination

 Complex Backend Filters

 Loading and Error states

 Elm Frontend Architecture


 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 what you'll write.

As with anything at Rock the JVM, this course is hands-on. We start by recapping the fundamentals of major Typelevel libraries (Cats, Cats Effect, Doobie, Http4s 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 decoupled layered architecture organically, without my imposing any style on you from the start. You will find it quite extensible and modular.

A big 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. In any event, we do extensive testing and our app will be robust.

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 or stateful component.

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


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 March 2023, I've taught Scala and all major tools to 80000+ 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.

In Collaboration with Riccardo

Riccardo Cardin is a proud Rock the JVM alumnus and senior software engineer focusing on high-performance systems in Scala, Kotlin and Java.

He is also one of the two leading lecturers of the Software Engineering course inside the Computer Science BSc, hosted by Dipartimento di Matematica of the University of Padova. 

Riccardo is actively interested in the application of design patterns and design best practices. He is constantly increasing his knowledge of the software's design and development continuously, which brought him to Rock the JVM.

With special thanks to

Dave Smith, the maintainer of Tyrian, for quickly reviewing and merging my PR that injects custom HTML. This allows our app to render Markdown on the frontend (pretty cool!).

@fellownoodle for the amazing Rite of Passage banner.

What's Included

📹 35 hours of video

👩‍💻 6200 lines of code

💼 1 full-blown product

🤯 1 mind blown away

Check out the lessons below - some are marked for free preview to get a sense of what we do in the course.

Available in days
days after you enroll
  Backend Stage 1: Job Management
Available in days
days after you enroll
  Backend Stage 2: User Management and Security
Available in days
days after you enroll
  Frontend Stage 1: Scaffolding
Available in days
days after you enroll
  Frontend Stage 2: User Management
Available in days
days after you enroll
  Frontend Stage 3: Job Management
Available in days
days after you enroll
  Frontend Stage 4: Cosmetics
Available in days
days after you enroll
  The Icing on the Cake
Available in days
days after you enroll
Available in days
days after you enroll
Available in days
days after you enroll

Take this course now!

100% Money Back Guarantee

If you're not happy with this course, I want you to have your money back. If that happens, email me at [email protected] with a copy of your welcome email and I will refund you the course.

Less than 0.05% of students refunded a course on the entire site, and every payment was returned in less than 72 hours.


1. Looks cool, but I would have used ______ effect library with ______ for frontend and ______ for backend! WAY BETTER! YOU DON'T KNOW ANYTHING

Riccardo and I have spent close to a year evaluating many different setups, boilerplates, libraries and approaches to building a full stack application with Typelevel. There are probably many great options, but I found this set of technologies to be the best fit - they are all well supported, actively developed and most importantly are the tech that I'd reach for when building a new application. Heck, I did build a new app with this stack.

It's important to note here that this course isn't just teaching you how to hook together a few libs - you are learning to think in and build full stack Scala 3 applications. The ideas behind this course transcend all libraries!

2. OMG this course is expensive!

Compared to the amount of TIME you'll spend grinding these lessons and experience on your own, it's nothing - take a developer's daily pay in your country (any country), multiply that by an honest number of days you'll need to build such an app alone, then come back to this page.

Not to mention you'll know how to build an app that can make your money back!

3. Is this course included with the membership?

No 😭 but hear me out. This course is at a completely different level compared to everything that's in the membership, so it'll stay separate. BUT! 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.

How to claim the discount: click on the membership card in the course dashboard, and you'll see the code inside.

4. Do you give a certificate?

Sure do! 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?

Yep! 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 or launch your own identical jobs platform so you can then say Rock the JVM sucks 😭

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 Typelevel 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.