An operator or a platform rarely commissions one game. It commissions a slate: a first title to open a market, a second to carry a mechanic the first could not, a third for a different audience or a different brand. The commercial instinct is to buy the pipeline once and run three titles through it. That instinct is half right, and the half it gets wrong is the half that decides whether the slate ships.
What can be reused is production capability — the maths framework, the client shell, the art direction, the test harness, the localisation and the release checklist. What cannot be reused is the game itself, and the reason is not artistic pride: it is that every review, certificate and change record in this industry is addressed to a single build. The platform approves one front version with one maths version. A regulator certifies the game, not the studio. A change control record names the game it changes.
That structure turns a slate into a sequence with dependencies, and the dependencies are worth writing down before the first title is commissioned rather than after the second one is rejected.

One approval covers one front version and one maths version
Engine’s approval guidelines are explicit about the unit of review: each approval request covers one front version and one maths version, reviewed together. The reviewer inspects functionality, clarity, communication and technical performance, and the outcome is a rating that becomes the game’s rating — it is locked once the game is released.
Three titles therefore produce three separate submissions, three ratings and three release decisions, whatever they share underneath. That is the first planning consequence: the shared layer buys engineering time, but it buys nothing at the review desk. A slate budget that assumes the second title inherits the first title’s approval is a budget with a hole in it.
The second consequence is tighter. A publisher with no live games can have one game in approval at a time; once its first game is live, it can have up to five. A slate whose titles are all being finished at the same time will queue behind itself, and the queue is not a formality — review order is set by when the approval thread was last updated, so every additional message moves a game to the back.
That changes the shape of a sensible slate plan. The first title is not just a product; it is the item that unlocks submission capacity for the rest. Sequencing the first one for an earlier, simpler scope is a planning decision, not a compromise.
What may be reused, and what reads as a reskin
The rules draw the line in a place that surprises teams who think of reuse as an efficiency question.
Engine requires games to be original designs. Pre-purchased or licensed games already available on other third-party sites are not permitted, and a game submitted to Engine has to be new rather than already released elsewhere. A slate cannot be built by republishing an existing catalogue under a new name, and a title commissioned for a platform cannot be quietly launched on a third-party site first in the hope of a second revenue line.
The sharper rule is the similarity lock. An approval thread can be locked when the game is too similar to another game — specifically a reskin, or the same assets or maths reused across games or studios. The lock runs from seven days to permanent, the game has to change significantly before resubmission, and in serious cases it must go back in as a brand-new game. Copying is enforced separately: each confirmed copy is disabled until it is changed and reviewed again, and repeated copying can end a studio’s access.
Read together, those rules define the reusable layer precisely. A shared client shell, a shared maths framework, a shared build and test pipeline, a shared art-direction system and a shared localisation workflow are engineering. The same symbol set recoloured, the same paytable with a new theme, the same background library under a new logo — those are the artefacts the similarity rule is written for, and the difference between them is not subtle once it is written into the commission.
There is also a design constraint that pushes in the same direction: Engine games are strictly stateless, each bet independent of the last, with no jackpots, gamble features, continuation or early cash-out, and at most twenty modes per game. A slate that shares a maths framework has to fit every title inside the same review envelope, including that mode ceiling.
The maths locks at release, so the slate carries the new mechanics
Post-release latitude is narrow. Once a game is approved for publication, only minor updates to address visual issues are permitted unless the Engine team agrees otherwise; changes to the underlying maths model, new game modes and modifications to gameplay mechanics are not allowed. The documentation for live games repeats it from the other direction: maths is locked once a game is live, and a change is accepted only to fix a confirmed bug, not to retune or rework, even at the same RTP and maximum win. Front-end updates are permitted for bug fixes, performance, new languages and small visual polish, provided the game stays recognisably the same.
For a slate, that is the difference between a roadmap and a wish list. The first title’s mechanic is fixed at approval. The second mechanic has to arrive in the second title, and a mechanic that was deferred has nowhere to live except a new submission. The post-approval scope brief works through what stays permitted once approval lands; the slate question is which title is responsible for which feature before any of them is submitted.
The mode ceiling belongs here too. A game can carry at most twenty modes, and the maths verification tests apply to every mode, so a title that inherits a framework with spare capacity still has to keep its own mode count inside the limit. Sharing a framework does not multiply the allowance.
In a regulated market, the shared core becomes a change surface
Where the slate also serves a licensed market, the shared layer stops being invisible. Great Britain’s testing strategy defines a major update as any software change that may affect the fairness of a game, and fairness includes the RNG, scaling and mapping, and the game rules including how the software processes them.
The Commission’s own worked example is the one every shared framework should read. An inefficient logging implementation was fixed by amending how the game symbol arrays were constructed, reducing CPU load. No rule changed. It was still classified as a major update requiring independent testing, because the software implementation of the rules had changed.
Applied to a slate, that means a performance or refactor change in a shared maths core can drag every live title that carries it back through external testing, one game at a time, with a change record per game. The change documentation requirement is already written per game: a unique change identifier, the game number or RNG identifier, the delivery channel, a description, a major or minor classification with its justification, the testing evidence and the manager’s authorisation.
The same holds where certification is game-level. In Brazil the certificate names the game rather than the studio, is issued specifically for the market, and has to be revalidated when a critical component is added, changed or removed — the Brazilian certification brief sets out the disclosures and the revalidation triggers. A shared core change is therefore not one event in a slate’s life; it is one event multiplied by the number of titles carrying it.
There is a real engineering conclusion here, and it is not “avoid shared code”. It is that the shared layer should be frozen early and versioned per title, so that a change is a deliberate decision with a cost attached rather than a by-product of work on the next game. A studio that can say which titles sit on which framework version, and what a change to that version would trigger, is answering a question the publisher will eventually be forced to ask.
What the slate plan should contain before commissioning starts
A slate brief that survives review does five things, and each of them is cheap to write at the start and expensive to retrofit:
- Name each title’s identity, not just its theme. A working title, the mechanic that belongs to it, and the audience or market it opens. If two entries cannot be told apart without the logo, the slate has a similarity problem before a line of code exists.
- Inventory the shared layer explicitly. Which maths framework, client shell, art system, build pipeline and test harness each title uses, and at which version. The QA split decides who signs the evidence for each column.
- Write the submission sequence as a calendar with dependencies. First title live and unlocking capacity, later titles staggered against the one-at-a-time limit and the thread ordering rule.
- State the per-market evidence each title carries. A game-level certificate, a test-house report, a platform rating: each belongs to one build and cannot be inherited from a sibling.
- Fix the change rule between titles. Who approves a change to the shared core, which live titles it forces back through review, and how the decision is recorded. The proposal comparison shows why this belongs in the commercial scope rather than in a later conversation.
None of that is exotic. It is the same discipline a single commission needs, applied to the fact that the second title will arrive while the first is still the only approved one.
The question to ask a studio
If you are planning several original titles and want to know whether a studio can run the slate rather than one game, the useful question is not how many titles it can build. It is which parts of its production it would reuse across your titles, which parts it would rebuild for each, and what a change to the reused parts would cost you in revalidation.
That answer separates a pipeline from a photocopier, and it is available before the first brief is signed. If you want the slate, the framework versions and the per-title evidence mapped against your own markets, request a project quote with the titles you have in mind; the studio engagement route describes how a full-cycle commission is structured around them.
Questions buyers ask
Can one studio deliver several original titles on a shared codebase?
Yes, and it is usually the efficient way to build a slate, provided the shared part is engineering rather than content. Engine’s approval guidelines treat a reskin — or the same assets or maths reused across games — as a similarity problem that can lock an approval thread from seven days to permanently, so the reusable layer has to be a framework, a shell or a pipeline, not a recoloured symbol set.
Does a second game inherit the first game’s platform approval?
No. Each approval request covers one front version and one maths version, reviewed together, and the rating is locked once that game is released. A publisher with no live games can have one game in approval at a time, rising to five once its first game is live, so a slate has to be sequenced rather than submitted in parallel.
Can the maths of a live game be updated for the next title in the series?
Not for retuning. Once a game is live, maths is locked and a change is accepted only to fix a confirmed bug; new modes and gameplay mechanic changes are not permitted after approval. New mechanics belong in a new title with its own submission, and each game carries at most twenty modes.
What happens to earlier titles if the shared core changes?
In a licensed market they can each need retesting. Great Britain’s testing strategy treats any software change that may affect game fairness, including how the software processes the rules, as a major update requiring external testing — its own example is a symbol-array construction change made purely for CPU load. A change record is required per game, which is why the framework version each title runs on should be recorded before commissioning.









































