Environments and releases

Every project has at least two environments, production and test. Each is a complete, separate backend for your game: its own players, config, flags, tours, blog, support, staff, sign-in settings and server keys. Services are switched on for the whole project, so every environment has the same ones.

Test for development, production for players

Point development builds, playtests and CI at test. Point the builds you ship to stores at production. Because nothing crosses between them unless you promote it, you can make as many test players as you like, try config changes and break things in test without any player noticing.

Your builds and servers choose an environment through these settings, usually set per build configuration:

Setting test production
API address https://api.greenmindmedia.com/api/platform/v1 the same
App key (only for EOS sign-in) skyforge_test skyforge
Server key (servers only) a key made in test a key made in production

The API address is the same for every environment. A server key or a player's token decides which environment a request acts in, so a test server key can never touch production data, whatever it asks for.

If you sign players in with EOS, enable EOS separately in each environment. You can use a different EOS client or deployment for each, and set a deployment id so that tokens from one EOS deployment are refused in the other environment.

Adding environments

An admin can add environments to a project, for example staging for release candidates or qa for an outside test team. How many a project can have, production and test included, is set by your org's plan: three on Free and six on Studio. Making one more than that is refused with quota-exceeded; the console's Usage page shows your plan.

An environment key is 2 to 20 characters: lower-case letters, digits and hyphens, starting with a letter. Its app key is the project key and the environment joined by an underscore (skyforge_staging).

A new environment starts empty: no players, config, flags or keys. The console cannot rename or remove an environment today, so choose names you will keep.

Moving config between environments

Make a config change in test, check it there, then move it to production. The project's Config pages are where that happens:

Page What it is for
Overview Every environment at a glance: what last changed and by whom, how far it is from production, and what is waiting
Compare What differs between two environments, to promote now or add to a release
Releases Changes queued for one environment, released together in one step, and rolled back if need be
Incoming Config sent from another deployment of the platform. Used by GreenMind's own games; a studio's environments have nothing here
History Every change applied to an environment: promoted, released or rolled back, by whom
Connections Config your game's own backend keeps, reached through a config connector
Assistants Tokens for AI assistants, and which environments are protected

An environment's own Config page has Compare and promote, which opens Compare with that environment chosen.

Compare

Compare shows what differs between two environments of the project, test and production unless you choose two others, in either direction. Nothing you do not choose changes.

What is compared

Compared Never promoted
Config values, config tables and config categories Players, sessions and saved player data
Feature flags (not whether they are on) and tours Whether a feature flag is switched on
Products, store listings and prices Orders and what players own
The game data definitions you edit in the console The blog, support, staff, keys and sign-in settings
Tables your game's own backend serves, through a connector A config table column each environment keeps itself

Rows are matched by what they are, not by their internal ids: a config value by its key, a flag or tour by its name, a product by its SKU. A row made in test arrives in production as that environment's own row. A table your backend serves is compared when both environments are connected to it; if its connector does not answer, Compare says so and leaves that table out rather than showing its rows as removed.

The blog is content, not config, so each environment keeps its own. Whether a feature flag is switched on belongs to each environment: a promoted flag arrives switched off, and one that already exists keeps its setting. Switch it on in production when you are ready. A config table column marked Each environment keeps its own value works the same way.

Choosing what goes

Differences are grouped by kind (config values, feature flags, products and so on), each marked New, Changed or Removed. Open a row to see every column that differs, as the target has it now and as it would be.

  • Every new and changed row is chosen to begin with. Choose a whole kind at once, or row by row.
  • A removal (a row only the target has) is never chosen for you. Choose it on its own if you mean to delete it.
  • Choosing a row chooses what it needs: a new config category value brings its member and category. Letting a row go lets go of anything that needs it.
  • Some rows cannot be promoted, and say why: a row the target keeps its own value for, a product that orders in the target still point at (switch it off instead of removing it), or a row something that stays still uses.

Add a note if you like. Then either promote now, or add to a release of the target, a waiting one or a new one, to go out later together with other changes.

Safe against changes in between

Promotion applies what you saw, or nothing. If a chosen row changed in either environment after the comparison was read, the promotion is refused, nothing is written, and the console lists the rows that moved. Compare again and choose.

All the chosen rows are written in one transaction, your backend's tables included, and every promotion is kept in the project's history: who promoted what, from where, and when. Your game and servers read the new values from their next request.

Flows

A flow is what runs in an environment when something happens: a trigger (an event, an action a client calls, a hook inside a request, a schedule, a webhook or a person) and the steps after it. The Flows section lists each environment's flows with the version that is live, whether a newer one is waiting, and a switch to turn it on or off there. A flow opens on a canvas, laid out by itself, with its versions, its runs and a place to try it without any effect.

Write a flow in the console, or write it as code with @repo/ext-sdk and push it with gm pub push and a publish key made on the environment's Publish keys page. A flow pushed from a repository is read-only in the console, so the files and the console never disagree; take it over from its page to edit it here. gm pub push only saves versions; gm pub push --live also makes them live, in a test environment only.

Saving a flow asks the engine to check it first, and every refusal names the step it is about. A protected environment's flows change only by a release: Compare lists flows and other definitions beside config, and what differs is queued in a release.

Releases

A release is a set of changes for one environment that take effect together, in one step, when you release it: a balance patch, a seasonal event, everything a new build needs. Make one on the Releases page, or from Compare.

  • Name it, and if it goes out with a game build, name the build too, so nobody releases its config before that build is live. The build is a note for people: nothing checks it.
  • Add changes from Compare, or from Incoming. Each is checked against what the release already holds, so a row the release already sets the way you chose is not added twice.
  • The review on the release's page checks every change against the environment as it is now. A row changed there since the change was queued is a conflict: choose Take the release's or Keep this environment's for each. Nothing is overwritten without a decision.
  • Release applies every change in it, in order, in one transaction: all of it or none of it. Games and servers read the new values from their next request.
  • Roll back puts every row the release changed back to what it was just before it was released. It is refused if any of those rows has changed again since: change them back by hand, or promote what they should be.
  • Delete a release that has not gone out yet. Nothing in it was applied, so nothing changes anywhere.

Who can do what

Each of these is a permission on an environment, which a role carries:

Permission Lets somebody
Read config Read config, compare environments, and see releases and history
Propose config Also make releases and queue changes in them, for somebody who may release to apply
Config Also change config, promote into the environment, and release

Each includes the ones above it. Comparing needs access to both environments, and shows only the kinds of config you may manage in both. Promoting or releasing needs, in the target environment, the same permission as changing that kind of config by hand there: Config for config values, tables and categories, Feature flags for flags, Tours for tours and Commerce for products. A role with Config but not Feature flags can promote config values and not flags.

Protected environments

A protected environment's config is changed only by a person signed in to the console. Every project's production was protected when protection arrived; protect a new one, or any other environment, on the Assistants page (it needs the Project settings permission).

Protection is about tokens, not people: whoever holds Config there still promotes and releases as before. A token, such as an AI assistant's, never writes or releases into a protected environment, whatever its owner may do. It can read it, and queue changes in its releases for a person to release.

Assistants

An AI assistant that speaks MCP can read and change your project's config at https://mcp.greenmindmedia.com/config. Make it a token on the project's Assistants page, and choose what it may do in each environment:

  • Read: list environments, read config and tables, compare, read history.
  • Read and propose: also make releases and queue changes in them.
  • Read and change: also change the environment directly, promote into it and release. Never offered for a protected environment.

A token never does more than its owner may do at that moment, checked on every call: take somebody's access away and their assistant loses it too. The token is shown once; give it to your assistant as a bearer token. Everything an assistant changes is in the environment's history under the token's name, and in the audit log.

The way to use one: let the assistant change test directly, then have it queue the same change in a release of production, and release it yourself once you have read the review.