ROBLOX Developer Roadmap

See Where You Place!

Quick Access

No elements found...

Level 1 = Foundation + Syntax

Beginner Rank

Level 1 teaches the fundamentals of Luau and Roblox scripting. It's the building blocks every developer needs.

The goal of level 1 is to be able to write functional scripts that can do things within ROBLOX. Your scripts don't need to be perfect or optimized, just functional.

Level 1 is for complete beginners, and it's the level everyone starts at.

In order to progress to level 2 you will need to understand each concept and method inside the list.

Level 1 Concepts

Core Syntax (The Absolute Basics)

Variables (using local + basic types: number, string, boolean, nil)

Operators (+ - * /, comparisons, and/or/not)

If/elseif/else statements

Basic error awareness (nil checks, simple debugging prints)

Control Flow

for loops (numeric + generic)

while loops

repeat loops

break, continue

Understanding execution order (top -> bottom)

Functions

Creating functions

Parameters + arguments

Returning values

Local vs global scope

Tables (entry-level understanding)

Arrays

Dictionaries

Accessing + modifying values

Looping through tables

Simple nested tables

ROBLOX Basics

Script vs Local Script

File structure [Workspace, ReplicatedStorage & ServerScriptService]

Referencing instances [workspace.Part]

Basic Properties (Transparency, Color, Parent, Name)

Changing properties via script

Instances & Objects

What is an Instance?

Creating Instances & understanding ClassNames [Instance.new]

Understanding more complex properties (Vector3, CFrame, NumberRange)

Instance methods [:Destroy() :FindFirstChild() :GetChildren()]

Events

Connecting functions to events

[.Touched]

[.Changed]

[.MouseClick]

Cleaning up RBXScriptSignals

Filtering Enabled (Surface Level)

Client vs Server (just the basic idea)

"Client handles visuals, server handles important stuff"

[RemoteEvents]

[RemoteFunctions]

Player Basics

Getting the player [Players.LocalPlayer, PlayerAdded]

Character basics [CharacterAdded]

Character parts (Humanoid, Head, HumanoidRootPart)

Basic UI

Understanding [ScreenGui] [Frame] [TextLabel] [TextButton]

Referencing UI objects

Changing text + visibility

Basic button interaction

Opening / closing interfaces for clients

Debugging Basics

print() debugging

Reading & understanding errors

Fixing simple mistakes (nil, typos, wrong paths)

What level 1 developers should be able to do

Make a part change when touched

Create a basic GUI button that does something

Store data in tables and loop through it

Write small scripts without copying tutorials

Understand why their code works (at a basic level)

Without this you will stay stuck

Most people skip these fundamentals and jump staight into advanced tutorials. Level 1 fixes that by giving you the core understanding everything else builds on.

You cannot move forward to complicated concepts without level 1 understanding. Each level after uses concepts that build on the foundation level 1 lays.

Where can I learn these concepts?

There are various resources that you can use to learn the concepts listed here in level 1.

Some include:

YouTube Tutorials

AI (Chat GPT, Claud, Gemini, Grok)

Luau/Lua Scripting Books

If you want to learn all of these concepts in one place without needing to look around for tutorials, we offer a level 1 scripting course that covers all of these topics.

Our level 1 scripting course: The Basics Of ROBLOX Luau takes you from complete beginner, to being able to make your first ROBLOX game

Learn More

Level 1 Scripting Course

Level 2 = Structure + Systems

Intermediate Rank

Level 2 is where you stop writing random scripts and start building organized, scalable systems.

You already know how to script. Now you’ll learn how to structure your code, separate responsibilities, and build systems that actually hold up as your game grows.

The goal of level 2 is to go from:
it works -> this is built correctly.

Level 2 Concepts

Code Organization & Structure

Understand how to organize a game using folders (ServerScriptService, ReplicatedStorage, StarterPlayer)

Use ModuleScripts to separate logic

Know when to split code into multiple scripts vs keep it together

Not writing overly long scripts (dumping everything into one script)

Create clean, readable file structures

Mastery Of Module Scripts

Return tables/functions from ModuleScripts

Share logic between multiple scripts using modules

Understanding basic patterns (utility modules vs system modules)

Avoid duplicated code by centralizing logic

Client vs Server

Clearly understanding the difference between a [Local Script] vs a [Server Script]

Know what should run on the server vs the client

Keep important logic on the server (network security)

Double check the [type()] of client arguments + clamping values

Remote Communication

Avoid playing ping-pong with [RemoteEvents] (send updates, not back-and-forth requests)

Throttle remote communication (prevent exploiting/bandwidth overuse)

Always double check (sanity check) data coming from the client

Thinking In Terms Of Systems

Think in systems instead of scripts

Break features into parts (ex: UI -> client -> server -> data)

Build systems that connect together instead of isolated scripts

Use a control hierarchy (no “god systems”)

Understand flow of logic across multiple modules

Reusability & Abstraction

Write functions that can be reused

Avoid copy-pasting the same logic everywhere

Pass data into functions instead of hardcoding

Use abstraction to create reusable blueprints

Data Handling Basics

Store player data in tables

Update and manage data cleanly

Understand basic data flow (where data lives and moves)

Intro to persistent data

Debugging & Problem Solving

Debug across multiple scripts

Trace where something is breaking (client vs server)

Use prints strategically (not at random)

Fix issues without relying on tutorials

Code Reading Ability

Read someone else's script and understand it

Follow logic across modules

Modify existing systems without breaking everything

Clean Code & Consistent Naming Conventions

Using naming conventions with purpose (camelCase, snake_case, PascalCase)

No excessive nesting (happy path + guard clauses)

You should be able to describe what your function does in one sentence

Name things by what they mean not what they are

Avoid abbreviations unless they are very short-lived or standard
([plr -> player], [c -> character])

What level 2 developers should be able to do

Structure a game using ModuleScripts and organized folders

Build a basic system (shop, inventory, round system, etc.)

Properly handle client/server communication using RemoteEvents

Avoid duplicated code by creating reusable functions/modules

Debug more complex issues without getting completely stuck

Read other people’s code and understand what it’s doing

Why most developers get stuck here

Most ROBLOX developers hit level 1... and stay there.

Why?

Because they never learn how to structure their code properly

They can script, but:

Their code is messy

Everything is duplicated

Systems break when they scale

They rely on tutorials for anything complex

Level 2 fixes that

Where can I learn these concepts?

You can learn these concepts from scattered sources:

Advanced YouTube tutorials (often incomplete or inconsistent)

AI (Chat GPT, Claud, Gemini, Grok)

Software engineering & game dev books (can be difficult for visual learners)

If you want to learn all of this in one place (without jumping between tutorials), we offer a level 2 scripting course that walks you through everything step by step. Not just what to learn, but how to actually implement it in real games.

ROBLOX Luau: Core Concepts shows you how to structure real projects, use abstraction properly, and build systems that will take you from Level 2 to Level 3

No More Boring Games

Level 2 Scripting Course

Level 3 = Production Thinking + Reliability

Advanced Rank

- update in progress...

Level 3 Concepts

title

- bullet 1

What level 3 developers should be able to do

Read other people’s code and understand what it’s doing