Roblox Engineer

• Server is authoritative — don't trust client for game state. Exploiters can manipulate anything client-side (speed, health, currency), so all game logic validation happens on the server.
• RemoteEvents for client→server requests, server→client notifications
• RemoteFunctions sparingly (blocks calling thread)
• Validate ALL client input on server — anti-cheat by design
• Replicate only what's necessary — minimize network traffic

Luau Best Practices

-- Type annotations (Luau supports gradual typing)
local function damage(target: Model, amount: number): boolean
    local humanoid = target:FindFirstChildOfClass("Humanoid")
    if not humanoid then return false end
    humanoid:TakeDamage(amount)
    return true
end

-- Use Roblox services properly
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
local DataStoreService = game:GetService("DataStoreService")

-- Module pattern
local CombatModule = {}
CombatModule.__index = CombatModule

function CombatModule.new(player: Player)
    local self = setmetatable({}, CombatModule)
    self.player = player
    self.cooldowns = {}
    return self
end

DataStore Best Practices

• Use ProfileService or DataStore2 wrapper for auto-saving and session locking
• Don't make raw DataStore calls without retry logic (6 second cooldown, throttling) — Roblox DataStore has strict rate limits, and unhandled throttling silently drops saves, losing player progress
• Session locking: prevent data corruption from multiple servers
• Auto-save every 30 seconds + on player leaving + on server shutdown
• Backup system: store last 3 versions of player data

Anti-Pattern Watchlist

• ❌ Game logic in LocalScript (client can exploit)
• ❌ Raw DataStoreService without retry/session locking
• ❌ wait() — use task.wait() (modern Luau)
• ❌ while true do without task.wait() — freezes thread
• ❌ Instance.new() in loops without Destroy() — memory leaks
• ❌ Trusting client RemoteEvent arguments without server validation

Phases

Phase 1 — Project Architecture

• Roblox Studio project setup with proper service organization
• Directory structure: ServerScriptService/, ServerStorage/, ReplicatedStorage/, StarterPlayerScripts/
• Module system: shared modules in ReplicatedStorage, server-only in ServerStorage
• Remote events/functions setup for client-server communication
• DataStore setup with ProfileService wrapper

Phase 2 — Core Gameplay

• Server-authoritative game systems
• Player data: stats, inventory, currency, progress (DataStore-backed)
• Combat/interaction system via RemoteEvents
• NPC AI (PathfindingService for navigation)
• Round/match system (for PvP/competitive experiences)
• Team/party system

Phase 3 — Economy & Monetization

• In-game currency (Robux → Premium currency → Soft currency)
• Game Passes for permanent unlocks
• Developer Products for consumables
• MarketplaceService integration
• Daily rewards / streak systems
• Trading system (if applicable) with server validation

Phase 4 — Polish & Publishing

• GUI/HUD using Roblox UI framework (ScreenGui, BillboardGui)
• Sound effects and music (SoundService)
• Particle effects (ParticleEmitter)
• Moderation: chat filter (TextService:FilterStringAsync), content moderation
• Analytics: performance stats, player retention
• Publish settings: max players, genre, permissions, age recommendations

Output Structure

src/
├── server/
│   ├── Services/          # Server-side service modules
│   ├── Components/        # Server game logic components
│   └── DataStore/         # Player data management
├── client/
│   ├── Controllers/       # Client-side controllers
│   ├── UI/                # GUI controllers and components
│   └── Effects/           # Visual and sound effects
├── shared/
│   ├── Modules/           # Shared utility modules
│   ├── Types/             # Type definitions
│   └── Constants/         # Game configuration constants
└── assets/                # Models, sounds, textures in workspace

Execution Checklist

• Roblox Studio project with organized services
• Shared/Server/Client module architecture
• RemoteEvent/RemoteFunction communication layer
• Server-authoritative game logic (never trust client)
• DataStore with ProfileService (auto-save, session locking)
• Core gameplay loop implemented
• Player data persistence (stats, inventory, progress)
• Economy system with Robux integration
• Game Passes and Developer Products
• Server-side input validation (anti-cheat)
• GUI/HUD system
• NPC AI with PathfindingService
• Chat moderation (TextService filter)
• Performance optimization (< 60ms frame time)
• Published with proper settings and age rating