Product development / Game Development
Game Development for a defined product and device scope.
Plan a game around its core loop, target hardware, progression and operating model. Explore mobile, PC, console, browser and multiplayer scope with engine choices, testable game rules and a receiving-team release path.
Discuss your project โContents ยท Game Development
Start with the task, then prove the target.
Start with the decisions a playable build must settle: genre, input, audience, session structure, target devices and the reason a player returns. A casual touch game, a progression-heavy title and a real-time competitive game need different content, networking and release plans. A design document should connect the rules, art, sound, accessibility and backend rather than become an untested feature catalogue.
For Unity scope, describe gameplay systems, ScriptableObject configuration and editor tools against that design. Separate mutable session state from shared tuning assets. For multiplayer, define authority over movement, scores, rewards and inventory before choosing Netcode for GameObjects, Photon or Nakama. A network SDK is not an anti-cheat system; validate critical actions on a trusted server where the product requires that trust.
Treat platform services as separate contracts: Game Center or Play Games sign-in and achievements, purchase receipts, ad callbacks, consent and account recovery. Plan repeatable signed builds and real-device profiling for each target. Live-ops services such as PlayFab, Firebase or Nakama need explicit responsibilities for saves, leaderboards, matchmaking, remote configuration, access controls and incident response. This is proposed engineering scope, not a claim that any listed backend is already connected.
Scope dimensions
Agree the custom interaction, target platforms, distribution and monetization/business services, inspected reuse, selected engine/renderer and source/licence terms. These are separate decisions; a codebase or catalogue label does not establish an included package.
Engineering scope checkpoints
- C# gameplay/configuration/editor tooling aligned to a reviewed design document.
- Multiplayer authority, results and rewards validated through the chosen trusted-server design.
- Platform sign-in, achievements, purchases and ad SDKs with current policy/lifecycle tests.
- Repeatable target builds with Unity Build Automation or GitHub Actions where selected, plus real-device evidence.
- PlayFab/Firebase/Nakama or another selected service for explicit saves, leaderboards, matchmaking and remote configuration scope.
Product and delivery boundaries
- Custom game scope: quote milestones after genre, content and target review.
- Platforms: list iOS, Android, PC and approved consoles only when included and supported.
- Monetization: scope ads, IAP, subscriptions or premium with eligibility and entitlement tests.
- Surrounding platforms: inspect any proposed web/mobile reuse separately; none is verified as a game.
- Engine choice: compare actual Unity, Unreal, Godot or browser-native requirements.
- Source rights: record custom work, reusable components, third-party assets and build/account handover.
Potential surrounding business workflows.
These source categories are retained to define possible scope, not as a claim of available templates, working inventory, customers or deployed products. Inspect any proposed starting code, asset rights and actual behavior. None of the listed capabilities is verified as included in a package.
Messaging community
Scope chats, calls, groups and media-sharing, with a separately verified privacy/encryption model. End-to-end protection is not established by a product label. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Property operations
Scope tenant access, rent/payment flows, maintenance tracking and accounting interfaces with permissions, audit and reconciliation. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Short-form social community
Scope posts, trends, hashtags, messages and real-time interactions with moderation, ranking rules and data/privacy requirements. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Membership community
Scope recurring subscriptions, exclusive content and community tiers, including entitlements, cancellations and creator/member administration. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Video community
Scope uploads, channels, subscriptions, advertising and live streaming with rights, processing, access and moderation responsibilities. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Discussion community
Scope topic boards, voting, comments, recognition/awards and moderation, with authorization and abuse handling. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Compare routes against the actual product.
On smaller screens, scroll the table sideways to read every column.
| Decision | Unity | Unreal | Godot / custom engine |
|---|---|---|---|
| Rendering | Choose a supported pipeline and measure content on targets. | Check feature/hardware support and actual packaged-frame costs. | Evaluate Godot renderers separately; custom rendering needs its own tooling and validation. |
| Reuse across targets | Shared C# and assets still need platform settings, plugins and QA. | Shared C++/Blueprints still need target settings and access. | Check actual exports/port layers; custom integrations need maintenance ownership. |
| Iteration | Evaluate editor, script, asset and build iteration on the actual team workflow. | Evaluate Blueprint/C++ iteration, cooking and binary-asset collaboration. | Evaluate supported language/tooling/export workflows rather than assume faster or slower. |
| Native integration | Verify plugins for required SDKs, ads and purchases. | Verify C++/plugin APIs, SDK rights and target access. | Check maintained bindings or budget each custom platform integration. |
| Fit | Test against the genre, content and receiving-team skills. | Test intended fidelity, devices and production tools. | Test engine/export suitability; a custom engine needs a clear technical reason. |
Choose by a representative slice
Use the actual content, inputs, audience devices and integration path. Preserve the configuration, measurements and unresolved constraints with the decision. No universal speed, reach, staffing or performance rank is implied by this comparison.
When to use another route
A conventional app may solve the task without a 3D engine. A browser viewer may avoid an installed runtime; a native build may fit hardware/offline needs; streaming may fit another fidelity/access model. Scope and test the alternative rather than assume a tool label settles the tradeoff.
A detailed guide to the engineering and buying decisions.
Which kind of game are you building, and what does each kind need?
Casual and hyper-casual scope centers on a readable mechanic, input feel, onboarding, short sessions and a bounded initial download. Mid-core scope adds progression, an economy, guilds or PvP and durable cross-device accounts. PC and console scope adds controller behavior, graphics settings, storefront services and approved platform access. Browser scope adds first-load budgets, focus and tab suspension, storage limits and touch input. Multiplayer is a separate design dimension: real-time versus turn-based, match lifecycle, authority, latency, reconnection and abuse handling must be tested, not inferred from an engine badge.
Unity, Unreal, Godot or WebGL - how is the engine chosen?
Choose the engine with a representative playable scene, not a ranking of vendors or talent pools. Unity offers a C# workflow and multiple build targets; Unreal combines C++ and Blueprints with rendering features whose hardware cost must be measured; Godot offers an MIT-licensed engine with platform-specific export constraints. Browser-native JavaScript/WebGL may fit a link-first game, while a custom engine needs a specific technical reason and a maintenance plan. Compare source access, art tools, package rights, licensing, device performance and the receiving team's ability to release the project.
How does a game go from design document to a playable build?
Move from the game design document to an input-and-rules prototype, then a representative playable slice, content production and release acceptance. Define what each build proves: the mechanic, the progression loop, a networked match, save recovery or platform submission readiness. Review actual target-device builds with representative art rather than rely on an editor recording. Track playtest observations separately from business hypotheses. A prototype that feels promising has not proved retention, monetization, balance or production stability.
What backend does a game need for accounts, saves, leaderboards and matchmaking?
A backend may own identity, cloud saves, inventory, matchmaking, leaderboards, sessions, receipts and moderation tools. Decide which data is authoritative, what happens during a disconnect and how conflicting saves reconcile. A leaderboard needs submission validation and abuse handling; an economy needs idempotent grants, audit records and reversals. Keep administrator powers behind authenticated server routes. Define data export, deletion, backups and a load-test scenario based on expected concurrent matches, not only account count.
Ads, in-app purchases, subscriptions or premium - how should a game make money?
Ads, in-app purchases, subscriptions and premium purchase each change the game design and policy work. Rewarded video should be voluntary, with server-side verification and duplicate-callback handling where a reward has value. Purchases need receipt validation, pending and cancelled states, refunds and restored entitlements. Subscriptions or season passes need clear benefit periods and content responsibilities. Premium and expansions need storefront entitlement checks. Test the loop without assuming that a monetization format guarantees revenue or that one billing route is valid in every storefront and region.
Can you port a game, or join our studio as a co-development partner?
Porting starts with rights and a reproducible source build, then input, rendering, plugins, saves, networking and platform-service differences. Compare current behavior before changing engine versions. Co-development needs module ownership, repository access, asset-locking rules, review responsibility and a shared build pipeline. A specialist task can be scoped separately when the existing studio owns integration and release. A broader engagement should identify the actual roles required without claiming that a named team is available before it is agreed.
What does a game cost, how long does it take, and should you hire a studio or freelancers?
Estimate after the playable scope, art inventory, target matrix and online systems are understood. Separate engineering from art creation, music rights, engine and plugin licences, servers, ads tooling, QA hardware, certification and ongoing operation. Ask for milestones linked to evidence such as an accepted slice, recovery tests and a receiving-team build. Choosing a studio or freelancer is a responsibility question: who owns technical direction, integration, target-device QA, release, security and support? Catalogue prices and promised turnaround are not a current game-development offer.
Implementation checklist 1
- Casual/hyper-casual: test core mechanic, short-session input feel, onboarding and initial download.
- Mid-core: define progression, economy, guild/PvP and cross-device durable accounts.
- PC/console: define graphics, controllers, storefront services and approved platform access.
- Browser: test link entry, download size, focus/suspend behavior and mobile/desktop input.
- Multiplayer: define real-time/turn-based authority, matchmaking, reconnection and operating load.
Implementation checklist 2
- Ads: define voluntary rewarded placements, consent, callback verification and interruption limits.
- Purchases: validate currency/cosmetic/level entitlements and receipts, including pending, refund and restore states.
- Subscriptions/passes: define benefit periods, renewal disclosures and content obligations.
- Premium/expansions: verify storefront entitlements, rights and target-platform release responsibilities.
Architecture with explicit ownership and failure behavior.
Feature modules and shared core
Keep gameplay features with their scripts, prefabs, scenes and tests, with a shared core for genuinely reused services. Separate scene loading from game rules and network-session state. Test a module being disabled or replaced without breaking progression or a running match; folder names alone do not establish those boundaries.
Configuration and runtime state
Use ScriptableObjects for authored configuration where appropriate, with validated values and clear ownership. Keep mutable session state in separately managed objects. Events need lifetimes, unsubscribe behavior and error handling. A blanket ban on a pattern is less useful than tests showing deterministic rules, reset behavior and no hidden dependencies between scenes.
Profiling, pooling and data-oriented work
Profile CPU, GPU, allocations and memory on the intended release hardware. Use pooling and Addressables where they reduce measured costs; bound pool sizes and release content handles. Consider Jobs, Burst or DOTS for demonstrated CPU-heavy work only after measuring the complexity and platform constraints. Preserve a performance capture and repeatable test scene with each acceptance build.
Preserved technical example and its implementation limits.
Illustrative code. Review its missing dependencies and implementation boundaries before using it in a product.
Scroll the code sideways on smaller screens to read each complete line.
using UnityEngine;
public enum GameMode { Casual, Ranked, Tournament }
[CreateAssetMenu(fileName = "GameConfig", menuName = "Game/Config")]
public class GameConfig : ScriptableObject
{
[Range(2, 16)] public int maxPlayers = 4;
[Min(30f)] public float roundSeconds = 180f;
public GameMode defaultMode = GameMode.Casual;
}
public sealed class GameSession
{
public GameConfig Config { get; }
public float TimeLeft { get; private set; }
public GameSession(GameConfig config)
{
Config = config;
TimeLeft = config.roundSeconds;
}
public bool Tick(float deltaTime)
{
TimeLeft = Mathf.Max(0f, TimeLeft - deltaTime);
return TimeLeft > 0f;
}
}What the preserved example demonstrates
GameConfig holds tuning values in a Unity ScriptableObject, and GameSession advances a timer in a plain C# class. The separation can make the timer testable without a running scene. UnityEngine is still a required dependency for the configuration type and attributes.
What it does not implement
The sample does not validate null or invalid configuration, negative or non-finite delta time, lifecycle resets, pause rules, networking, server authority, persistence or an entire match. Inspector attributes are not server-side validation. Treat the local timer as an illustration, not as trusted ranked-match or reward logic.
Three engagement routes to scope in writing.
These are options to evaluate, not a claim that a ready-made build, dedicated team, fixed-price package or support service is currently available. A browser 3D starter, where proposed, must be inspected just like any other reused code.
Reuse after inspecting the starting point
Scope and quotation
Inspect the proposed version and document exactly what is reused, adapted, excluded and newly built. Request a current itemized quote and acceptance plan; no fixed offer or delivery duration is established here.
Catalogue or starter fit
Compare the real code, supported targets, dependencies and licences against the required workflows. A business web/mobile base is not automatically a game or XR build. For a 3D starter, inspect its actual rendering and interaction limits.
Brand and configuration
List brand changes, UI, content, permissions, product variants and configuration work explicitly. Confirm whose assets and approvals are required and test the resulting paths rather than assume white-labelling is only a logo change.
Administration
Confirm whether any admin/dashboard is included and inspect it with safe test data. Scope roles, authorization, audit, content/data operations and recovery; a label does not establish a working backend.
Rights, confidentiality and support
Agree source/asset delivery, reusable and third-party licences, confidentiality and the actual support window in writing. Test independent receiving-team access and build/release rather than infer unrestricted ownership from an archive.
Custom implementation
Written scope and quote
Describe target hardware, inputs, scene/content requirements, rules, integrations and exclusions. Establish milestones, assumptions and a current itemized quote after feasibility work, without adopting unsupported source prices or launch periods.
Architecture for the product
Document boundaries among scenes, interaction, business rules, data and services. Test critical rules independently, then prove integration with production assets and the actual target configuration.
Working reviews
Agree a review cadence and the evidence expected from each increment. Inspect real builds, failed/denied/loading states and unresolved risks; a video or attractive scene is not acceptance of backend or target-platform behavior.
Release responsibility
List each store/platform or hosting/CDN route, account owner, signing and privacy work. Check current requirements and follow-up responsibilities. Engineering completion, submission and approval are separate events.
Source and rights
Name the complete project/source, editable assets, build settings, scripts, history and documents to deliver. Separate custom-work assignment from engine, reusable-component and marketplace licences.
Ongoing development and operation
Retainer terms
Define the service period, included capacity/work, billing, notice, cancellation and handover. Treat upgrades, new features, defects and infrastructure operation as distinct obligations; no published monthly package is verified here.
Named responsibility
Confirm who owns technical decisions, implementation, QA, release and support, plus backup contacts. This is a contract question rather than a claim that a dedicated team is already assigned.
Direct working channel
Agree authorized contacts, communication channels, escalation and decision records. Keep private source material and credentials out of informal messages and limit access when responsibilities change.
Review and deliverables
Agree planning/review cadence, acceptance and release notes. Keep a visible defect/risk register and test evidence, not an assumption that a recurring meeting proves a working increment.
Capacity and scope changes
Record changes to targets, content, service capacity and responsibilities before proceeding. Preserve source/account access and an exit plan so changes do not create avoidable operational dependence.
Source-specific acceptance areas.
Architecture
Separate presentation, game rules and persistence/network adapters. Inspect dependency direction and a feature being tested without loading an entire scene.
Testable rules
Exercise plain C# rules outside Play mode where appropriate. Cover timers, rewards, progression boundaries, invalid configuration and reset behavior, then test the scene integration separately.
Performance
Record frame time, hitches, memory, load times and thermal behavior from target-hardware builds with the actual content. Editor observations are diagnostic, not release acceptance.
Device and input QA
Test the agreed phone, PC, controller and other target matrix. Include focus loss, suspend/resume, denied permissions, interrupted purchases, display changes and network reconnection.
Build pipeline
Pin editor, packages, toolchains and build settings. Reproduce each included target through authorized build infrastructure and store signing material securely.
Security
Assume the client can be inspected or modified. Keep privileged keys off the client; validate valuable match outcomes, inventory changes and rewards on an appropriate trusted service.
Store readiness
Check signing, age ratings, privacy, purchases and each storefront requirement against the actual product. Record account access and submission responsibilities without promising approval.
Six release and receiving-team gates.
Review changes with the actual assets
Require traceable review of scripts, shaders, configuration, prefabs/scenes or Blueprint/binary changes. Use the appropriate diff tools and a representative build. Record who may merge and how exceptions are approved. Source review, content rights and target-device behavior are related checks, not substitutes for each other.
Automated and functional tests
Test rules, data boundaries, loading/recovery and critical user paths with suitable unit, integration and scene/functional tests. Add representative screenshot comparisons where useful. Agree meaningful thresholds and retain failed cases; a coverage percentage does not establish that a tracking, networking or comfort failure was tested.
Profile representative release behavior
Capture CPU/GPU time, memory, loading and sustained-session behavior on the actual target matrix with production content. Diagnostic development/Test builds can aid profiling; verify the real release/Shipping behavior too. Record configuration and limitations rather than compare an editor capture with a customer device.
Deliver a reproducible handover
Require the pinned editor/engine/toolchain, package manifest, full project/source/history, editable licensed assets, build settings/scripts and setup guide. Include backend/API contracts, deployment/recovery and post-launch runbooks where applicable. Transfer secrets through authorized secure access, not source or prose documents. Have the receiving team reproduce a release.
Separate preparation, submission and approval
List platform/store or hosting requirements for the actual target: account ownership, signing, privacy, age ratings, listing/screenshots, certificates, caching and versioned assets as appropriate. Assign review/rejection follow-up and rollback responsibility. A passing build is not store approval, and a static demo is not a managed production service.
Agree monitoring and real support
Define errors and performance signals, private-data minimization, consent where required, alert routing and a named responder. Include crash symbols where applicable and test a deliberate failure. Agree actual support duration/hours, severity and escalation separately from new work. A dashboard, telemetry SDK or source-page support claim does not establish active operation.
Technology options and their responsibility boundaries.
The full source tool inventory is retained below. Tool choice is conditional on the product and documented current support, not a claim of a standard preconfigured stack. Review package lifecycle, security updates and recurring service charges with the receiving team.
Unity
Role to evaluate: Default engine ยท C# ยท URP. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Unreal Engine
Role to evaluate: C++ and Blueprints ยท high-end 3D. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Godot
Role to evaluate: GDScript ยท light 2D titles. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Netcode for GameObjects
Role to evaluate: Multiplayer networking option; authority and validation must be designed and tested.. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
WebGL / HTML5
Role to evaluate: Browser games ยท instant play. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
In-app purchases
Role to evaluate: StoreKit ยท Play Billing ยท server receipts. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Ad mediation SDKs
Role to evaluate: Rewarded ยท interstitial ยท banner. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Addressables
Role to evaluate: Streamed levels and content drops. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Game Center / Play Games
Role to evaluate: Sign-in ยท achievements. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
PlayFab / Nakama
Role to evaluate: Accounts ยท saves ยท leaderboards. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Firebase
Role to evaluate: Auth ยท FCM ยท Analytics. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Photon Engine
Role to evaluate: Hosted rooms ยท matchmaking. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Remote Config
Role to evaluate: Live-ops tuning without an update. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Unity Build Automation
Role to evaluate: CI ยท signed builds per platform. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Sentry
Role to evaluate: Crash ยท performance monitoring. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
Node.js API
Role to evaluate: Custom game server logic ยท admin API. Confirm the pinned version, supported target/provider, licence, data flow and build/runtime integration. Include only selected tools in the actual scope; this list does not establish a configured service, paid account, working backend or available specialist.
From brief to a reproducible release.
Brief and confidentiality
Describe users, the core workflow, existing systems, sensitive data and business constraints. Agree confidentiality and information-sharing boundaries before handing over restricted material.
Scope and plan
Choose the build route and inspect any proposed existing base. Write the role matrix, architecture, integration contracts, exclusions, acceptance tests, dependencies and milestone plan with an itemized quote.
Build and review
Use version control, repeatable environments and checks suitable for the project. Review working increments against the agreed workflow, including loading, empty, denied and failure states. Track scope changes explicitly.
QA and release decision
Run the agreed functional, integration, accessibility, security and performance checks against the release build. Rehearse migration and recovery, preserve evidence and decide which issues block launch.
Launch and handover
Release through authorized accounts with a tested recovery path. Deliver source, documents and operating access, confirm monitoring and support ownership, and have the receiving team demonstrate the essential operations.
External dependencies are not engineering completion
List developer/platform verification, signed licences, source/asset access, payment eligibility, customer approvals and store review separately. Set dates only after the required inputs and release gates are understood. No catalogue turnaround or instant update guarantee is adopted here.
Build a scope-based budget, not a catalogue assumption.
For Game Development, price the real interaction/content work, target matrix, source-asset conversion, engine/renderer and packages, backend/API integrations, networking or streaming where needed, physical/browser QA and independent release/handover. Distinguish creation, reuse, integration and operation.
Reuse or starter scope
Client surfaces
Identify whether the deliverable is a surrounding business platform, a browser 3D starter, a game/XR project or an integration between them. Count the actual clients and targets; do not substitute a catalogue name for a specification.
Admin/dashboard
List included operator functions and inspect existing behavior. Price missing modules, permissions, data migration and audit separately rather than assume an admin is standard.
Branding
Define brand assets, UI changes, content, app/store identities and white-label limits, including any upstream attribution requirements.
Source handover
List source/history, editable assets, package manifests, build settings and documents, with reusable/third-party licence restrictions.
Support
Agree the real support start event, duration, severity terms, hours and exclusions. No support window is guaranteed by this page.
Confidentiality
Agree permitted access, use, retention and deletion before sharing restricted specifications or assets. An NDA must be an actual agreement, not a badge.
Custom build scope
Responsibilities
Identify engineering, content/technical art, backend, QA and release responsibilities for the actual work. Confirm capacity rather than advertise unverified staffing.
Architecture
Price target-specific code, data boundaries, asset pipelines and integration contracts against the written requirements.
Reviews
Agree a cadence of reviewable builds and acceptance evidence, with loading, error and denied states included.
Distribution
Itemize store/platform packaging or hosting/CDN, signing, listings/privacy and review follow-up appropriate to each target.
Rights
Separate custom source/assets from engine, marketplace and reusable components. Verify account ownership and an independent release route.
Milestones
Link billing, acceptance, changes and cancellation to written terms. No amount, fixed duration or automatic no-risk payment arrangement is established here.
Continuing work scope
Accountability
Record who owns ongoing engineering, operation and incident response, with coverage and escalation.
Work categories
Separate content/features, engine/browser/platform updates, defects, security maintenance and operating services.
Planning
Agree review cadence, priorities, deliverables and evidence for each work period.
Communication
Name authorized contacts and decision channels, with a record of scope and release approval.
Changes
Set how capacity, scope, costs and notice change, and how source and account access remain available.
Rights over time
Keep ongoing custom-work ownership, third-party licences, dependency updates and handover obligations current.
Build scope
Count the user roles, permissions, workflows, client surfaces and admin operations. Identify where an inspected existing component actually fits and which gaps need new work. Price the agreed outputs rather than a catalogue label.
Integrations and data
Itemize provider onboarding, external-system contracts, legacy migration, data quality, reconciliation, media, messages and real-time work. Include test environments and provider restrictions, not only a connection button.
Non-functional requirements
Document accessibility, device/browser coverage, traffic and latency targets, resilience, retention and data location. Regulatory and security obligations need defined controls and review; they are not automatic properties of a framework.
Operation and ongoing costs
List hosting, database, storage, bandwidth, payment fees, maps, email/SMS, monitoring and any AI or video usage separately from engineering. Include maintenance, backups and support, plus who owns and pays each account.
Commercial terms
Request a current itemized written quote, acceptance-linked milestones and a change process. Confirm taxes, recurring charges, cancellation and rights. No price, duration, included support window or service level is established by this page.
Separate quote lines
Request separate lines for inspected reuse/starter work, custom implementation and continuing development/operation. Where a surrounding web/mobile platform is proposed, separate it from the game/XR/3D project. Vendor engine licences, assets, cloud/GPU/CDN services, hardware and provider charges need their own current checks; this page does not establish amounts or turnaround.
Illustrative scope review, not a customer outcome.
The challenge to define
A hypothetical multiplayer game brief can combine a short-session mechanic, progression, ranked rooms and a live-ops console. The challenge is keeping those systems consistent when players disconnect, purchases arrive late, content versions differ or a server restarts. This is an example for scope review, not a customer story or a deployed title.
A proposed implementation to test
A proposed implementation could split pure game rules from Unity presentation, use a documented network-authority model, store durable inventory on the backend and expose narrowly authorized operator tools. Acceptance should include replayable rule tests, interrupted matches, duplicate rewards, old-client compatibility, save recovery and a release build on the least capable supported device.
Acceptance and unresolved evidence
The preserved source gives conflicting delivery periods in its example narrative and project brief. Neither is adopted as a promise or outcome. Ask what each period included, which starting components existed, which platforms were accepted and whether any result has permissioned evidence. Success for a new brief should be defined as measurable technical and player-experience criteria, with commercial results treated as hypotheses.
How to evaluate relevant references.
No named customer testimonial, rating, award or project result is asserted here. The inherited source repeated media-platform testimonials that do not establish game, XR or browser-3D delivery. Do not treat those names or source outcome figures as permissioned evidence for this service.
Inspect relevant evidence
Ask for a current, permissioned reference whose actual scope matches the intended target, content and integration. Establish the supplier role, what was custom, what was reused, who operates it now and what can be shown without exposing private customer information.
Separate demonstration from operation
A scene recording, screenshot or public landing page can illustrate one state. Inspect the actual build, authorized backend paths, failure/recovery and receiving-team release evidence before relying on a deployment claim. Keep any third-party review in context with its author, date, scope and verification.
Diligence before making a commitment.
Legal identity and contract
Verify the contracting entity and authorized signatory against current official records. Match the entity on the scope, invoice and rights agreement. Do not infer registration, history or financial standing from a website badge.
Evidence behind claims
Ask for dated, permissioned evidence behind project counts, app launches, outcome figures and technical claims. Check what was actually delivered, what belonged to an existing component and what remains a prototype or proposed scope.
Independent reviews
Open current review records and inspect author, project scope, date and platform verification. Treat ratings as context rather than a substitute for source, acceptance and receiving-team checks.
Relevant product inspection
Request access to the actual version proposed for the project, with safe test data and agreed permissions. Walk through the required role paths and failure states. A screenshot, catalogue name or attractive landing page does not establish a working backend.
Permissioned references
Where a past project matters, ask for a reference and permission to discuss it. Establish the supplier's role, delivery boundaries and current operator without republishing private customer information.
Named responsibilities
Ask who owns engineering decisions, QA, release approval and support. Record backups for unavailable contacts and how changes and unresolved risks will be reported. Do not substitute stock biographies or unverifiable team claims.
Verify people and access
Confirm named responsibilities and authorized source/account access for the specific work. A leadership page, company name or staffing count is not proof that a team is assigned or a contract is valid.
Prefer evidence to badges
Require current, permissioned source and target-device evidence behind material claims. Unsupported registration numbers, project totals, guaranteed results and source-page facts-ledger assertions have not been carried into this service description.
Agree milestones rather than slogans
Put acceptance, dependencies, change control and exit/recovery terms in the actual agreement. Do not convert the source page's launch periods or work-free guarantee into a new promise.
Industry context changes the acceptance criteria.
Healthcare & Life Sciences
Anatomy visualization, procedure rehearsal or patient education needs domain-owner review, licensed content and a clear boundary between educational visualization and a regulated clinical function. Do not imply that realistic 3D establishes medical accuracy, certification or an appropriate care decision.
Telemedicine
Visual explainers can accompany a care workflow, but the clinician and authoritative medical record remain separate. Scope sensitive data, consent, access, accessible alternatives and what happens when a visual session fails. Avoid displaying identifiable health information in analytics or shared scenes.
Fintech
Data visualization, onboarding or gamified education needs authoritative calculations outside the scene, clear disclosures and access controls. A compelling animation is not financial advice or a verified transaction. Define audit, privacy and the limitations of any simplified model.
Retail & E-commerce
Product configurators, try-on and showrooms need accurate licensed models, valid option combinations and server-owned prices/inventory. Explain visual/fit limitations, keep conventional product information usable and test failed model loads before connecting the experience to purchase.
Media & Entertainment
Games, interactive trailers and fan experiences need content/music/likeness rights, age/safety review and a tested distribution route. Separate proposed engagement mechanisms from actual audience results and define moderation for any shared or user-generated content.
Creator Economy
Effects, virtual events and digital merchandise need creator rights, consent for likeness and a clear publishing/moderation model. Scope payment/entitlement services separately from 3D interaction, with provider-policy checks and accessible non-immersive routes.
Transportation & Mobility
Vehicle configurators, training and route visualization need accurate source dimensions/data, target-specific performance and domain review. A simulation or preview does not establish road safety or certified instruction. Document data freshness and the authoritative system behind any live view.
Food & Beverage
Menus, dish previews and loyalty interactions should preserve readable item, allergen and price information outside 3D. Review imagery and scale limitations, accessible alternatives and any promotion/loyalty rules. A model cannot establish nutritional or allergen safety.
Rights, support and receiving-team handover.
Written scope
Describe included workflows, roles, interfaces, integrations, data and acceptance evidence. Record exclusions and assumptions so a feature name cannot stand in for an implementation contract.
Source, licences and accounts
Put the custom-code assignment, reusable-component licence and third-party restrictions in the contract. Identify every app, API, admin console, migration, infrastructure script and design asset being delivered. Keep cloud, domain, billing and developer-account ownership explicit. A source archive alone does not establish unrestricted rights or an independent release path.
Dependencies and changes
List customer inputs, provider approvals and third-party limits. Track changes with their scope, cost and milestone impact before proceeding. Separate engineering completion from app review, payment eligibility and the decision to open to customers.
Support and ongoing work
Agree the support start event, duration, working hours, contact route, severity definitions and response versus repair commitments in writing. Separate defects against accepted scope from new features, provider changes, security maintenance and operating work. Monitoring needs a named responder and an escalation route; a dashboard alone is not support.
Receiving-team handover
Require repository history, a dependency and licence inventory, setup instructions, API contracts, database migrations, environment-variable names, deployment and rollback steps, and an operating runbook. Transfer secrets through a secure channel rather than source control or a document. Have the receiving team build, restore and release with its own authorized access.
Questions about Game Development.
What game engines does Omnistu use for game development?
Compare Unity, Unreal, Godot or a browser-native route against the game design, target devices, content pipeline and receiving team. Inspect a representative build, package licences and platform/export requirements. No engine choice is established until the actual scope is reviewed.
How much does game development cost at Omnistu?
The amount depends on the accepted scope and the inspected starting point. Request an itemized current quote covering roles, workflows, integrations, data, QA, release and handover, with provider charges and continuing operation separate. This page does not establish a fixed price or an automatic package inclusion.
Does Omnistu deliver the full source code?
Require the full delivery inventory and rights terms in writing: custom code assignment, licences for reusable and third-party parts, source history, API and migration documents, build and release scripts, and authorized account access. Have the receiving team reproduce a release. Do not assume ownership or absence of future licence fees from a source-code promise alone.
How fast can a game realistically be delivered?
Set milestones after inspecting the scope, repository and provider dependencies. Distinguish build and acceptance from developer-account verification, payment onboarding and app-store review. Do not use a catalogue turnaround as the delivery promise for a custom product.
Unity vs Unreal - which does Omnistu recommend?
Compare the actual title on Unity, Unreal, Godot or a browser-native route using a representative scene. Include art workflow, plugin rights, build targets, licensing, network design and receiving-team skills. No engine is automatically best for every genre or device.
What is included in the admin panel with every delivery?
Write an admin role matrix for the actual product: users, content, orders/bookings, operational settings, reports and any financial actions. Define server-side authorization, audit and recovery for sensitive changes. Inspect each required module in the proposed version rather than assume a complete back office is bundled.
Does Omnistu handle App Store and Google Play game submission?
For a product with mobile apps, scope account ownership, signing, provisioning, screenshots, listing and privacy answers, test accounts and review coordination. Verify any payment and account-deletion requirements against current store rules. Submission does not guarantee approval or determine review time; state responsibility for rejections and follow-up.
What happens after the app is delivered if there are bugs?
Confirm the actual support window and start event, defect definition, response hours, escalation and charges in the signed terms. The duration mentioned in the question is not verified as an available offer here. Keep new features, provider changes and continuing operations separate from in-scope defect repair.
How does Omnistu handle NDA and confidentiality?
Agree confidentiality before exchanging restricted specifications or data. Record permitted recipients, use, retention, deletion and any subcontractor access. Set custom-code assignment and reusable/third-party licence terms separately. Do not assume a signed NDA, source ownership or permission to publish a project until the actual agreement covers it.
Can a game on a custom engine use professional ad mediation?
A custom-engine game may integrate an ad SDK if the provider supports the target platform and integration route. Verify maintained native bindings, privacy/consent, store rules, SDK lifecycle, reward verification and test modes. Do not assume that mediation or monetization is available simply because the engine can call native APIs.
Do you build real-money or skill-based games?
Real-money and skill-based mechanics need a separate jurisdiction, age, licensing, store and payment-eligibility review before any implementation or commercial commitment. A skill label does not establish legal status or provider approval. No gambling operation, payment account or compliant deployment is offered or verified by this page.
Can you build a browser game for a brand campaign?
A brand browser game can be scoped around a short playable loop, the host site, target phone/browser matrix and an accessible non-game route. Set download, input, privacy, analytics and context-loss/fallback requirements. Verify asset rights and campaign claims without assuming that a browser build guarantees reach or engagement.
Implementation and platform references.
Use documentation for the selected versions, devices, configuration and operating region. Project acceptance depends on the implementation, not a tool label.
- Unity editor and service-provider licence terms
- Unity render-pipeline/platform comparison
- Addressables operation handles and WebGL Task limitation
- AR Foundation anchor creation/lifecycle
- AR Foundation provider/optional anchor support
- ARCore supported devices
- ARCore depth capability
- ARCore Cloud Anchors network requirements
- XR Interaction Toolkit haptic API
- Unity visionOS interaction sample
- Epic engine licensing
- Epic Unreal Engine EULA
- Epic Nanite/Lumen XR restrictions
- Epic Pixel Streaming requirements
- Godot licensing and platform/export guidance
- WebGL resource and performance guidance
- WebXR session lifecycle
- Three.js WebGPU renderer
- Three.js KTX2 loader
Bring your workflows and operating requirements.
Share the users, business rules, current code and data, integrations, device/browser targets and receiving team. Agree the build boundaries, rights, acceptance evidence and operating responsibilities before implementation.
Discuss your project โ