A public game can no longer be disposable

The last 24 hours in Nima Project concentrated activity in three places:

• the shared workspace
• world-cup-porra
• world-cup-api

There was no large feature expansion like the previous day. There was something more important for an app that is already live:

Ultimate Porra started assuming that a public game cannot be operated like a disposable object.

Once a game already has users, predictions, phase locks and scoring consequences, it is not enough to make it visible on the home screen. The product has to govern it more carefully.

The clearest signal: deletion can no longer be a casual click

Several frontend commits tell the same story together:

• Add entry pool card management menu
• Hide public pool management menu
• Require name confirmation before deleting games
• Polish entry cards and recovery flow

The sequence matters.

First the product opens the door to managing games from the card itself. Then it hides that option when it should not be available. Finally, deletion stops being a light action and starts requiring name confirmation.

That is a product-tone correction.

A couple of days ago the game was becoming the main unit of the experience. These 24 hours add the uncomfortable but necessary part: if the game is important, destroying it has to feel important.

This is not only defensive UX.

It is an admission that the interface is no longer manipulating prototypes. It is manipulating objects with history.

The backend follows through: better soft delete, better restore, fewer ambiguous mutations

The same thesis appears in world-cup-api:

• Add safe game management endpoints
• Block locked public game joins
• Add admin restore for soft-deleted games
• Restrict API CORS origins

And it also appears in two intermediate commits that harden rules before destroying data:

• Lock preview predictions server-side
• Prevent deleting locked match predictions

This is a fairly serious shift.

The API stops behaving like a tolerant CRUD surface and starts behaving like an operational surface with state.

A game is no longer simply:

• created;
• used;
• deleted.

It becomes something more real:

• it can be locked;
• it can reject new joins;
• it can require safer deletion;
• it can end up soft-deleted;
• and it can need explicit administrative restore.

That changes the meaning of the system.

The question stops being "which endpoint does this" and becomes "which state is this game in, and which mutation is still legitimate".

The auth conversation points in the same direction: do not hide the problem, route it

The June 17 Codex sessions surfaced a very concrete decision about user registration in Porra.

The deployed close-out summarized it like this:

• Porra no longer treats it as ok: true.
• It returns 409 USER_EMAIL_ALREADY_EXISTS.
• The screen shows a clear notice.
• A visible Reset password action appears.
• It does not redirect automatically.

And the BFF contract documentation was updated in the same direction:

the UI may show a recovery action, but it must not send the reset email in the background or force the user into another flow.

That may not look like a story about games, but it actually is.

As the product matures, it stops hiding operational friction behind neutral responses. It starts acknowledging the real state and offering the correct next action.

The same thing is happening with games:

• if it is locked, you should not be able to join;
• if deletion is risky, you should have to confirm it;
• if it was removed, you need an explicit restore path;
• if the email already exists, you should see the real way out.

The app stops pretending simplicity. It starts orchestrating it.

Even scoring moves into "one visible truth" mode

Not everything in the window was about operating games, but two commits work as a useful capstone:

• Unify displayed score source
• Fix wildcard bonus scoring

The first fits an idea that had already been pushing through the product: there should be one visible score source.

The second fixes a subtler leak: if wildcard bonus scoring does not match between frontend and backend, operational trust weakens immediately.

That matters because guardrails are not worth much if the product protects the lifecycle of a game but fails to protect how its points are interpreted.

The last few hours show the opposite:

• mutation is better restricted;
• recovery becomes explicit;
• and scoring gets aligned again.

The layout fixes are not decoration; they are part of the new contract

Several small frontend commits could look like pure polish:

• Show locked public pool countdowns
• Lock public World Cup entry countdown
• Anchor entry card status footer
• Tighten entry card countdown status
• Fix home live match card and entry carousels
• Fix tablet carousel overflow and home live points

But they all push in the same direction.

If a game can lock, if an account can need recovery and if a dangerous action needs context, then the entry card stops being a pretty cover.

It has to become a readable state surface.

Countdowns, anchored footers, fixed overflow, stable live points: these are not isolated details. They are the visual infrastructure that lets those restrictions be understood without turning the app into a confusing mess.

What really changed in these 24 hours

The easy summary would be:

• more endpoints;
• more validations;
• more polish.

But the deeper story is different.

Ultimate Porra started treating the public game as a persistent object, with memory and operational risk.

That forces three things at once:

• better permissions and locking;
• better deletion and restore paths;
• and better visible state explanation for players and operators.

What I take from this stretch

• Managing a game from its own card immediately forces the product to harden what can be deleted and when.
• Soft delete and restore mark the step from functional demo to product that can be operated without panic.
• A join blocked by phase or state belongs in the backend, not only in UI copy.
• The USER_EMAIL_ALREADY_EXISTS registration flow with a recovery CTA follows the same logic: stop hiding the real state and offer the right action.
• Unifying the visible score source and fixing wildcard bonus scoring protects trust right when operations become stricter.
• Countdown, card and carousel fixes are part of the state contract, not mere decoration.

These 24 hours did not add the loudest novelty in the project.

They added something more valuable:

the idea that a public game can no longer be treated as something easy to create, touch and delete, but as a live object that has to be locked, explained, restored and scored with discipline.

Part of my product and platform notes. Follow the blog or contact me.