Sano — Roblox developer

Roblox systems that scale with the game

I design and ship modular, production-minded systems for demanding Roblox games — mostly in Roblox-TS, with Luau where the engine needs it.

View work Contact

Open to collaborations

initLog.ts

private initLog(data: LogData, cframe?: CFrame) {
  const logPart = clone((a) => a.Utils.Log);

  logPart.CollisionGroup = "Log";

  logPart.GetPropertyChangedSignal("CFrame").Connect(() => {
    const cframe = logPart.CFrame;

    data.pos = [cframe.X, cframe.Y, cframe.Z];
    data.rot = cframe.ToOrientation();
  });

  if (cframe) {
    logPart.CFrame = cframe;
  }

  this.logMap.set(logPart, data);
  logPart.Parent = this.folder;
}

About

Profile

I build on Roblox with one priority: modular, performant systems that stay maintainable — instead of brittle scripts that fight you every time the game grows.

Most of my work is in Roblox-TS for strong typing, predictable architecture, and a codebase that scales with the project. Day-to-day tooling: Rojo for repo structure, Wally / Pesde for dependencies.

The aim is experiences that feel closer to a real game product: solid technical foundations, room to iterate without rewriting everything from scratch.

Execution stack

TS
Roblox-TS
Typed workflows, clear boundaries between systems
Lua
Luau
Native scripting where it still makes sense
{ }
Architecture
Modular design, minimal one-off glue code

Skills

Technical stack

Tools and domains I work in most often on production Roblox games.

Roblox-TS

Typed Luau, predictable module boundaries, and patterns that stay readable when the codebase grows.

Luau

Performance-aware scripting on the engine side, with type annotations where they actually help.

Rojo & tooling

Filesystem-first workflow, reproducible builds, and dependency hygiene (Wally / Pesde).

Data & persistence

DataStore flows with sane retries, migrations, and player data patterns (e.g. ProfileStore).

Networking

Typed remotes, middleware, and permission checks so clients cannot drive server authority by accident.

Performance

Streaming-aware design, careful hot paths, and optimization that starts from architecture — not panic patches.

Featured project

Tech Island

Sandbox / automation game — resource loops, machines, and a codebase built to ship updates without rewiring the world every month.

Players gather resources, build machines, and tighten production loops. Under the hood it’s plugin-shaped architecture, typed networking, and serialization that doesn’t fall over when the map grows.

Machines & pipelines
Automation, farming hooks, and production chains players can reason about.
Custom serialization
Binary-friendly structures (NBT-style thinking) for world-scale data, not giant JSON blobs.
Analytics
In-game signals and logging so balance and economy decisions are grounded in data.
Progression
Stats, achievements, playtime, exploration — wired without spaghetti.

Roblox-TSRojoWallyProfileStoreDeltaCompressRemoPlugins

Case study Play on Roblox

Expertise

What I bring

Concrete areas where I’m comfortable owning design and implementation on a live Roblox title.

System architecture

Plugin-style feature boundaries so content ships without touching the core loop every time
Data-driven gameplay (resources, machines, farming) instead of hard-coded one-offs
Custom binary serialization where JSON would explode size or latency
Design that favors systems and contracts over copy-paste logic

Networking & data

Typed remotes (e.g. Remo) with middleware and explicit server authority
Permission layers so clients suggest, servers decide
DataStore flows with safe retries, versioning, and migration paths
Multi-server consistency patterns when the experience spans shards

Player-facing layer

Progression surfaces: stats, achievements, playtime, meaningful milestones
UI that can react to live data without fighting React-Roblox boundaries
Notifications and update delivery that don’t spam or desync
Exploration and discovery that tie back to progression systems

How I work

Readable code first — future you is also a stakeholder
Performance considered from layout of data and update frequency, not only micro-opts
Internal tools (Studio plugins, generators) when they remove whole classes of bugs
Long-term ownership: fewer clever hacks, more boring reliability

Contact

Let’s talk

Roblox systems, tooling, or technical direction — short intro emails work best.

If you’re building or maintaining a Roblox game and need someone who thinks in architecture, data, and live constraints — send a note. I’m open to collaborations, contract work, and scoped technical reviews.

[email protected]

Email me