# RS School App: Open-Source TypeScript LMS for RS School Engineering Courses

> RS School App is the MPL-2.0 licensed TypeScript application powering app.rs.school, the educational platform of RS School. It helps students progress through front-end, back-end, mobile, and data science engineering courses, with a monorepo architecture built on Next.js, NestJS, and PostgreSQL.

**rolling-scopes/rsschool-app** — An application for the RS School education process

- Repository: https://github.com/rolling-scopes/rsschool-app
- Website: https://app.rs.school
- Stars: 10,400 · Forks: 224
- Language: TypeScript
- License: MPL-2.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/rolling-scopes-rsschool-app

## What RS School App Is and the Problem It Addresses

RS School is an educational organization that runs free engineering courses. The courses cover front-end development, back-end development, mobile development, and data science. The school operates at a scale where a generic learning management system would require significant customization, and a spreadsheet-based process would not scale either.

RS School App is the custom-built platform that manages the educational process: student registration, course enrollment, task tracking, grade management, mentor assignments, and the workflow between students and reviewers. It serves as the operational backbone of app.rs.school, the live production platform that thousands of students use. The repository contains the full source code for that platform, including both the front-end and back-end services.

The README describes the platform as helping "thousands of students become front-end, back-end, mobile, and data science engineers." The application status page is at status.rs.school, which tracks the uptime of the production deployment. Financial contributors can support the project through Open Collective at opencollective.com/rsschool.

## Technology Stack and Architecture

The application is built entirely in TypeScript. The front-end uses Next.js and React. The back-end has two layers: a NestJS application (the actively maintained backend) and an older Koa.js server, which the README marks as deprecated. Both run on Node.js. End-to-end testing uses Playwright.

The database is PostgreSQL, accessed through TypeORM at version 0.3.20. The monorepo uses Turbo to coordinate scripts across workspaces. The root package.json specifies Node.js version 22 or higher and npm version 10 or higher as required engine versions.

Deployment uses Podman rather than Docker. The infrastructure runs on AWS: EC2 for compute, RDS for PostgreSQL, S3 for file storage, and CloudWatch for logging. Monitoring uses Sentry (with a project URL in the README at rs-school.sentry.io) and Checkly for uptime checks. GitHub Actions handles CI/CD, with the workflow configuration in .github/workflows/. The docker-compose.yml at the repository root defines the production multi-container setup using images from the GitHub Container Registry (ghcr.io/rolling-scopes/).

The formatting tool is oxfmt, configured in .oxfmtrc.json, which the ci:format script runs in check mode during CI. ESLint is version 10.0.3 with a boundaries plugin that enforces import rules between workspace layers.

## Setting Up the Application Locally

The README's Getting Started section lists five commands to bring up a local development environment:

```bash
npm install
```

This installs dependencies in the root folder and in the client/ and server/ workspace folders.

```bash
npm run db:up
```

This starts a local PostgreSQL instance using Podman Compose with the configuration in setup/docker-compose.yml.

```bash
npm run db:restore
```

This restores a test database snapshot from setup/backup-local.sql into the local PostgreSQL instance. After installing dependencies and starting the database, copy the .env.example files from server/ and nestjs/ to create the actual .env files:

```bash
npm start
```

This starts the application by running both the Next.js front-end and the REST API server. The site is then available at http://localhost:3000. The README also documents running the documentation locally using docsify at port 4000.

## The Monorepo Workspace Structure

The repository is organized as an npm workspace monorepo with three workspaces: server (the deprecated Koa.js backend), nestjs (the active backend), and client (the Next.js front-end). The root package.json defines the workspaces as nestjs and client; the server workspace is listed separately.

Turbo orchestrates tasks across workspaces. The root package.json scripts use turbo run to execute start, build, lint, test, compile, and openapi commands across all workspaces in parallel. This means running npm run build at the root compiles all three workspaces using the turbo build pipeline defined in turbo.json.

Shared dependencies are pinned at the root level. The overrides field in the root package.json pins @nestjs/common, @nestjs/core, and @nestjs/platform-express to version 11.1.29, ensuring consistent NestJS versions across both nestjs and any transitive dependencies. Common dependencies like axios at 1.8.4, dayjs, lodash, and typeorm are also managed at the root.

## Docker Compose Configuration and Deployment

The docker-compose.yml in the repository root defines a production-style multi-container setup. The client container runs from the image ghcr.io/rolling-scopes/rsschool-app-client:master on port 8081. The nestjs container runs from ghcr.io/rolling-scopes/rsschool-app-nestjs:master on port 8082. Both images are hosted on the GitHub Container Registry.

The environment variables for the nestjs service expose the depth of the configuration required: PostgreSQL host, credentials, and database name, GitHub OAuth credentials for authentication (client ID, secret, and webhook secret), JWT secret key, AWS credentials and region, and admin user lists. The RSSHCOOL_USERS_ADMINS variable in the docker-compose.yml shows hardcoded admin GitHub usernames, which illustrates that this is a platform tightly coupled to RS School's specific operations rather than a generic LMS.

## Where RS School App Has Limitations as a General LMS

RS School App is purpose-built for RS School's specific educational workflow. The admin usernames hardcoded in docker-compose.yml, the GitHub OAuth dependency for authentication, and the AWS infrastructure assumptions mean that deploying the application for a different organization requires significant configuration changes.

The Koa.js backend is explicitly marked as deprecated in the README, which means the codebase carries legacy code alongside the active NestJS backend. Teams that want to contribute or maintain the platform need to understand which code paths are still active and which are being phased out.

The database setup requires a test snapshot (setup/backup-local.sql) for local development, which means contributors cannot start with a completely empty database. The snapshot is restored via the db:restore script, which runs a psql command inside the Podman-managed container. The snapshot size and content are not documented in the README.

The application assumes GitHub as the authentication provider. The docker-compose.yml environment variables include RSSHCOOL_AUTH_GITHUB_CLIENT_ID, RSSHCOOL_AUTH_GITHUB_CLIENT_SECRET, and RSSHCOOL_AUTH_GITHUB_CALLBACK, which means any deployment requires creating a GitHub OAuth App. Organizations whose students do not already have GitHub accounts face this as an additional prerequisite.

## RS School App vs Moodle: Custom Platform vs General LMS

Moodle is the most widely deployed open-source learning management system, used by universities and training organizations worldwide. It provides a general-purpose course management platform with a plugin system for customization.

RS School App differs in that it is not a general-purpose LMS but a custom application built around RS School's specific process: mentor-mentee pairings, code review workflows, task scoring, and community-driven course progression. Moodle covers a wide range of course delivery models from self-paced to instructor-led, with grade books and activity tracking. RS School App covers a specific engineering bootcamp model where student progress depends on completing code assignments reviewed by mentors.

Organizations running mainstream courses where instructors post content and students complete quizzes should use Moodle or a similar general LMS. Organizations running bootcamp-style engineering courses with code review workflows can use RS School App as a reference architecture.

## Conclusion

Developers who want to run RS School courses on their own infrastructure can use rsschool-app as a starting point, but the deployment requires AWS services (EC2, RDS, S3) and GitHub OAuth credentials as documented in the environment variable list. Those contributing to RS School's existing platform can use the local npm start workflow for development. The MPL-2.0 license allows incorporating the code into proprietary products as long as modifications to the MPL-2.0 files themselves are open-sourced.

## FAQ

### What is RS School App and what does it do?

RS School App is the open-source TypeScript application powering app.rs.school, the platform for RS School engineering courses. It manages student enrollment, task tracking, mentor assignments, and grade management for front-end, back-end, mobile, and data science courses.

### What technology stack does RS School App use?

The front-end is Next.js and React; the back-end is NestJS (and a deprecated Koa.js layer) on Node.js 22+. The database is PostgreSQL via TypeORM. The monorepo uses Turbo. Deployment uses Podman on AWS EC2 with RDS for the database.

### What license is RS School App released under?

RS School App uses the Mozilla Public License 2.0 (MPL-2.0). This allows use in proprietary products, but modifications to the MPL-2.0 licensed files must be made available under the same license.

## Sources

- [Issues](https://github.com/rolling-scopes/rsschool-app/issues)
- [License: MPL-2.0](https://github.com/rolling-scopes/rsschool-app/blob/master/LICENSE)
- [Project website](https://app.rs.school)
- [README](https://github.com/rolling-scopes/rsschool-app/blob/master/README.md)
- [rolling-scopes/rsschool-app on GitHub](https://github.com/rolling-scopes/rsschool-app)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rolling-scopes-rsschool-app