Skip to content
Tutorials Center
My learning

Topics

Lesson 34 of 37 ยท Publishing and Monetization

Live Operations: Analytics, Performance and Updates

Run a published Roblox experience well: read retention and engagement analytics, find performance problems with the MicroProfiler, use StreamingEnabled, log errors and ship updates safely.

Publishing is the start of the work, not the end. Once players arrive you need to know whether they enjoy the game, whether it runs smoothly on weak phones, and what to change next. This is called live operations. This lesson covers the numbers worth watching, the tools Roblox provides, and a few techniques that keep an experience fast.

Roblox's dashboards and profiling tools are not available on this site, so they are described in words and read-only code. The runnable examples are JavaScript stand-ins that compute the same ideas from sample data, such as retention and frame budgets.

The numbers that matter

Open your experience in the Creator Hub and look at the Analytics pages. The key metrics are:

  • Concurrent players and visits: how many are playing now, and how many joins you get.
  • Session length: how long players stay. Short sessions often mean a confusing start.
  • Retention: the share of new players who come back after day 1, day 7 and day 30. This is the best single signal that people like the game.
  • Conversion and revenue: the share who buy something, and the average spent per paying player.
  • Funnels and custom events: where players drop out of a sequence such as tutorial, first round, first purchase.
  • Device and country breakdown: shows who plays and on what hardware.
  • Crash and error reports: the stability of your experience.

Do not chase one number. A game with a huge number of visits and almost no day-1 retention is a leaky bucket.

A healthy game loop

Acquire Players find and join.
Engage A fun first 5 minutes.
Retain They return tomorrow.
Earn Fair purchases, repeat visits.

Fix retention before you buy more traffic.

1 / 2

Computing retention yourself

Retention is simple arithmetic: of the players who joined on day 0, how many came back on day N? Here is the calculation on sample data.

JS Day-N retention (JavaScript stand-in)

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Day 1 retention is 50 percent here (3 of 6 came back) and day 7 is 50 percent too. Real experiences often see much lower numbers, so compare with your own past updates rather than with someone else's.

Custom analytics events

Roblox also lets you log your own events and funnels with AnalyticsService, so you can see where players quit.

LUA
local AnalyticsService = game:GetService("AnalyticsService")

-- Log a step of the onboarding funnel
AnalyticsService:LogOnboardingFunnelStepEvent(player, 3, "Finished tutorial")

-- Log a custom event with a value
AnalyticsService:LogCustomEvent(player, "LevelCompleted", 1)

Choose a small set of meaningful events. Too many events become noise.

JS Funnel drop-off

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The funnel tells you where to spend effort: here, the tutorial loses 38 percent of new players, so improving it will likely help more than adding a new shop item.

Performance: the frame budget

A smooth game draws at least 30, ideally 60, frames per second. At 60 fps each frame has about 16.7 ms to run scripts, physics and rendering. Weak phones have much less headroom than your PC.

Tools to find slowness:

  • MicroProfiler (Ctrl+F6 in Studio or in game): a live chart of what each frame spends its time on. Scripts that run long show up as wide bars.
  • Script Performance window (View > Script Performance): lists which scripts use the most time.
  • Developer Console (F9 in game or /console): memory, network and log output while playing.
  • Creator Hub performance metrics: crash rate, memory and frame rate by device.
  • Benchmarks in code: os.clock() around a block.
LUA
local start = os.clock()
doExpensiveThing()
print(("took %.2f ms"):format((os.clock() - start) * 1000))

Common causes of lag and their fixes:

Problem Fix
Thousands of parts Use MeshParts, merge parts, reduce detail, turn on StreamingEnabled
Loops doing heavy work every frame Run less often, cache results, use events instead of polling
Many scripts for many identical objects One script plus CollectionService tags
Heavy FindFirstChild or GetDescendants calls in a loop Cache references once
Huge textures and uncompressed sounds Lower resolutions, remove unused assets
Creating and destroying thousands of instances Reuse objects (object pooling)
Too many network messages Send less, batch updates, avoid firing remotes every frame

StreamingEnabled is a property of Workspace that loads parts of the map near the player and unloads distant parts. It greatly reduces memory and join time in big worlds, but scripts must not assume every part exists on the client, so use WaitForChild and design with streaming in mind.

Check a frame budget

This stand-in adds up the cost of tasks per frame and compares it with the budget for a target frame rate.

JS Frame budget calculator

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Moving one wasteful task off the per-frame path brings the frame under the 60 fps budget.

Handling errors in the wild

Players will find bugs you never saw. Roblox shows script errors that happen in live servers in the Creator Hub, and the ScriptContext.Error signal lets you log them yourself.

LUA
local ScriptContext = game:GetService("ScriptContext")
ScriptContext.Error:Connect(function(message, stackTrace, script)
	warn("Script error:", message, "in", script and script:GetFullName())
end)

Add pcall around risky calls, and keep detailed logs for important systems such as saving and purchases.

A safe update routine

  1. Write down what you changed and why.
  2. Test in Studio, then in a published test place with a few players.
  3. Publish at a quiet time, watch the error and analytics dashboards for the next hour.
  4. Be ready to revert from Version History (see publishing).
  5. Share patch notes in the description or a group announcement, so players see that the game is alive.
  6. Feature flags help: keep a Config module (or DataStore-backed settings) so you can turn a new feature off without republishing.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which metric best shows that players enjoy your game enough to return?

    Retention measures how many new players come back, which reflects lasting interest rather than one-off visits.
  2. 2. Roughly how many milliseconds does one frame have at 60 fps?

    1000 ms divided by 60 frames is about 16.7 ms per frame.
  3. 3. What does StreamingEnabled do?

    Streaming reduces memory and join time in large worlds, but scripts must not assume every part is loaded.
  4. 4. A leaderboard that refreshes every frame is a problem because

    Heavy work every frame eats the frame budget. Refresh slowly changing data rarely.

Summary

  • Watch retention, session length, conversion, funnels and crash reports, not just visits.
  • Log a few meaningful custom events to see where players leave.
  • Aim for a 16.7 ms frame at 60 fps; use the MicroProfiler and Script Performance to find slow code.
  • Reduce part counts, cache references, avoid per-frame heavy work and consider StreamingEnabled.
  • Update carefully: test, publish quietly, watch dashboards, and keep the ability to revert or toggle features.

Next: Project: Build an Obby