Product development / AR App Development
AR App Development for a defined product and device scope.
Design augmented reality around supported devices, real-world tracking and useful interactions. Explore product placement, try-on, field guidance and navigation with explicit asset, permission, offline and tracking-quality requirements.
Discuss your project โContents ยท AR App Development
Start with the task, then prove the target.
AR starts with a physical task: placing a product at scale, checking an instruction against real equipment, previewing an appearance or finding a route. Define the environment and failure behavior before choosing an SDK. Camera permission, tracking state, lighting, reflective surfaces, motion and device capabilities all affect whether an overlay is usable. A polished screen recording is not evidence that the same experience works on every phone.
Separate scene understanding, tracking and rendering from accounts, catalogues, business rules and content administration. Choose plane, image, face, body, object or geospatial tracking for the actual task, then check provider support on the intended device matrix. AR Foundation can share application code across providers, but it does not make their optional features, sensor quality or persistence behavior identical.
Plan a source-to-device asset pipeline for CAD, Blender or Maya inputs, with scale, pivots, materials, collision, LODs, textures and appropriate USDZ/glTF outputs. Test the optimized content in bright and dim spaces, with and without relevant depth hardware, under tracking loss and during sustained sessions. Include a non-AR path for unsupported devices or declined permission rather than strand the visitor behind a camera prompt.
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
- Native tracking: verify ARKit/ARCore features, 6DOF, planes and optional depth/occlusion per supported device.
- Shared code: evaluate AR Foundation/provider packages and any separately scoped OpenXR/headset work.
- Browser entry: test WebXR/AR routes on intended browsers and any native viewer such as Quick Look separately.
- Assets: define Blender/Maya/CAD conversion, USDZ/glTF output, scale, textures and LODs.
- Distribution: specify iOS AR requirements, Android AR Required/Optional strategy and the tested web fallback.
Product and delivery boundaries
- Custom AR scope: set milestones after tracking/device/asset feasibility.
- Platforms: state included iOS, Android and browser routes and their differences.
- Tracking: define supported 6DOF/visual-inertial/relocalization behavior with measured limitations.
- Without LiDAR: define the actual supported feature/fallback, not equal capability.
- Asset pipeline: name USDZ, glTF or FBX inputs/outputs where needed and verify licences.
- Source rights: agree project, editable assets, dependencies, accounts and receiving-team build access.
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.
Short-video community
Scope scrolling feeds, creator monetization/payouts, challenges and recommendations. AR effects or branded-camera features remain separate content/technical work. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Ride-hailing operations
Scope live location/dispatch, fare or driver bidding, separate rider/driver paths and operator administration. An AR route overlay is optional, not proof of a functioning dispatch backend. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Multi-service operations
Scope required ride, delivery and payment modules, shared identity and separate service permissions. Neither a module count nor a product name establishes live inventory. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Subscription streaming
Scope plan entitlements, viewer profiles and a browsable content library with actual licensed media, billing eligibility and playback paths. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Multi-vendor commerce
Scope catalogue, cart, checkout, payments and buyer reviews. Product-preview or AR integration needs a separate licensed-asset and validated-option contract. Define acceptance, operating ownership, failure/recovery and rights in the actual scope before relying on any proposed reuse.
Assistant integration
Scope conversation context, prompt templates and external API calls, with provider eligibility, privacy, authorization and safe failure 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 | AR | VR-first | Conventional mobile app |
|---|---|---|---|
| User reach | Supported camera-tracking devices or a separately tested browser route. | Requires compatible headset/runtime and safe physical setup. | Verify supported OS/devices and ordinary application access. |
| Spatial awareness | Track real-world surfaces/features with optional depth/anchors. | Create an immersive scene with device-specific tracking. | No spatial tracking unless separately integrated. |
| Development workflow | Scope tracking modes, assets, physical testing and integration. | Scope environment/content, input, comfort and headset testing. | Scope conventional screens, data, integrations and release. |
| Hardware access | Verify camera, IMU and optional depth/LiDAR support. | Verify hands/controllers/haptics and provider-specific capabilities. | Use required supported phone APIs without unnecessary camera tracking. |
| Fit | Try-on, placement, guidance or wayfinding with tested limitations. | Immersive simulation, training or worlds where a headset fits. | Use when 2D screens solve the task without a spatial layer. |
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.
What does an AR application development service include?
An AR engagement can cover use-case and device scoping; tracking-mode selection; conversion of source 3D assets; native Swift/Kotlin or Unity interaction; browser entry where appropriate; real-device QA; and release/handover. Specify which of these are included. Devices without depth or LiDAR need an agreed alternative, not an implied equivalent. Record whether the build needs plane detection, occlusion, reconstruction, image recognition or other features and how the application responds when the capability is missing or temporarily unavailable.
ARKit, ARCore, Unity AR Foundation or WebAR - which should you build on?
ARKit and RealityKit fit an Apple-specific application; ARCore fits supported Android devices; Unity AR Foundation supplies a shared abstraction with provider plug-ins; WebAR may fit a link-first campaign or preview. These routes are not interchangeable. Check the precise browser APIs, device support, permissions, package versions and distribution model. Native capabilities may require a platform-specific path. A feature that exists in one provider cannot be assumed on the other, even when the same C# component is used.
Can Cordova or another hybrid framework build an AR app?
A hybrid framework can host ordinary UI around an AR view, but HTML or Cordova does not itself supply reliable native tracking. Inspect the actual maintained bridge, supported SDK versions, lifecycle behavior, camera ownership and build process. Decide whether the AR portion is a native module, a Unity integration or a browser experience. Test navigation away from the camera, app suspension, low memory, permission changes and returning to the scene. A hybrid wrapper should not be advertised as automatic cross-platform AR equivalence.
Which AR use cases are worth building?
Retail try-on needs the relevant face/body features, calibration and appearance limitations. Product placement needs correct scale, contact and user-controlled repositioning. Indoor navigation needs surveyed/mapped references and a route graph, not a claim that GPS becomes accurate inside. Training and field guidance need verified instructions, revision control and safe behavior when an overlay drifts. Marketing effects need a tested QR/link and browser route. Each use case needs a non-AR alternative and acceptance evidence that matches the task rather than a generic tracking demo.
What limits AR on real phones, and how do you test it?
Tracking depends on visible features, lighting, movement, camera/sensor quality and supported APIs. Test initialization, plane discovery, drift, relocalization, occlusion, thermal behavior and interruptions using production content on named phones. Depth support is a separate capability on Google's supported-device list; LiDAR is not present on every iPhone. Avoid claiming perfect floor lock or a universal frame rate. Preserve test conditions, failure footage, frame timing and memory measurements so a supplier and receiving team can reproduce what was accepted.
What does AR app development cost, and how long does it take?
Scope costs around platforms, tracking modes, asset volume, fidelity, existing code, backend integrations and release responsibilities. Navigation mapping, cloud/shared anchors, geospatial services and managed content add separate work and potential recurring charges. Agree which assets are supplied, which need repair and which must be created. A written quote should separate engineering, licences, asset production, hardware, hosting and support. Set milestones after a feasibility build on representative devices; a catalogue delivery period does not establish an AR schedule.
How do you choose an AR app development company?
Choose a supplier by inspecting a build relevant to the intended tracking and environment. Ask which phones were tested, what happens when tracking fails, where spatial data goes and which source assets and accounts are handed over. Require a package/version list, permission/data-flow description, device matrix and test evidence. Establish who is responsible for asset accuracy, safety review, QA, release and support without relying on project-count badges, fabricated testimonials, company-registration claims or a staffing promise that has not been confirmed.
Implementation checklist 1
- Scope the use case, supported phones and behavior without depth or LiDAR.
- Choose required plane, image, face, body, object or geospatial tracking and verify provider support.
- Define a licensed source-asset pipeline to optimized USDZ/glTF with correct scale and materials.
- Scope Swift/Kotlin, Unity or browser AR views and the host application/lifecycle integration.
- Require real-device tests, release responsibilities and source/project/editable-asset handover.
Implementation checklist 2
- Retail try-on: verify relevant face/body tracking, material/lighting limits, consent and appearance caveats.
- Placement: validate scale, planes, adjustment/reset and non-AR dimensions without promising physical fit.
- Indoor navigation: scope mapped references/markers/beacons and route graph with safe low-confidence behavior.
- Training/field service: verify equipment tracking, content revision/safety and actual offline prerequisites.
- Marketing: test QR/link entry, required browser capabilities, permissions and a useful fallback.
Architecture with explicit ownership and failure behavior.
Scene understanding, tracking and rendering
Use scene understanding to identify usable planes, images or other required trackables before placing content. ARCore depth and ARKit reconstruction are optional/provider-specific capabilities, not universal baselines. Keep the tracking-state model visible to the interaction layer so a lost plane or failed initialization produces guidance rather than misleading placement.
Six-degree-of-freedom tracking and anchors
Visual-inertial tracking combines camera and motion signals, but drift and relocalization still need testing. Scope local-session anchors separately from saved, cloud, shared and geospatial anchors. Query optional support at runtime and define retention, network and privacy requirements. LiDAR meshes are a device-specific input, not proof of accurate navigation or persistent placement.
Rendering and content budgets
Choose the graphics backend supported by the pinned engine/provider instead of assuming one fixed Metal/OpenGL ES configuration for every target. Use measured material, light, texture, geometry and LOD budgets. Check appearance, scale, occlusion and frame timing on the least capable included device, with sustained camera use and thermal behavior in the test plan.
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 System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem.EnhancedTouch;
using UnityEngine.XR.ARFoundation;
using UnityEngine.XR.ARSubsystems;
using Touch = UnityEngine.InputSystem.EnhancedTouch.Touch;
[RequireComponent(typeof(ARRaycastManager))]
public class PlaceOnPlane : MonoBehaviour
{
[SerializeField] GameObject productPrefab;
static readonly List<ARRaycastHit> hits = new();
ARRaycastManager raycaster;
GameObject placed;
void Awake() => raycaster = GetComponent<ARRaycastManager>();
void OnEnable() => EnhancedTouchSupport.Enable();
void OnDisable() => EnhancedTouchSupport.Disable();
void Update()
{
if (Touch.activeTouches.Count == 0) return;
var touch = Touch.activeTouches[0];
if (touch.phase != UnityEngine.InputSystem.TouchPhase.Began) return;
if (!raycaster.Raycast(touch.screenPosition, hits, TrackableType.PlaneWithinPolygon))
return;
Pose pose = hits[0].pose;
if (placed != null) Destroy(placed); // one product at a time
placed = Instantiate(productPrefab, pose.position, pose.rotation);
placed.AddComponent<ARAnchor>(); // tracking keeps it locked to the floor
}
}What the preserved example demonstrates
PlaceOnPlane uses EnhancedTouch, ARRaycastManager, a PlaneWithinPolygon hit and Instantiate before adding ARAnchor. It needs Unity, the Input System, AR Foundation/provider packages, a configured XR scene and a valid prefab. The example is kept as recorded, not rewritten into a claim of a tested application.
Anchor creation is not guaranteed
Current AR Foundation documents that adding ARAnchor at runtime can fail; the component then disables itself and is not tracked. Unity recommends TryAddAnchorAsync, or verifying trackablesChanged when using the component route. The original example does not perform that verification, and its floor-lock wording is not a guarantee.
Missing product behavior
Add permission/session handling, null and capability checks, placement limits, tracking-loss UI, anchor/content cleanup and persistence rules for the chosen versions. Local anchors are not automatically saved or shared. Cloud Anchor hosting/resolving requires a working internet connection and a separate privacy/operation plan.
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.
Frame time and thermal behavior
Set per-device acceptance targets for production scenes, then measure sustained camera/tracking sessions. A nominal refresh rate is not a guarantee of stable tracking or safe overlay alignment.
State separation
Keep catalogue, pricing, instructions and account rules outside the camera-view implementation. Model permissions, initialization, limited tracking, lost tracking and retry as explicit states.
Physical profiling
Profile real phones using the actual assets and release configuration. A simulator or Unity editor cannot establish camera tracking, device heat or deployed memory behavior.
Device and environment QA
Include named iPhone/Android models, relevant depth/LiDAR variants, bright and dim rooms, low-texture surfaces, fast movement, obstructions and interrupted sessions.
Build pipeline
Pin AR Foundation, provider packages, native tools and signing requirements. Reproduce iOS and Android builds with agreed automated checks and on-device smoke tests.
Data and credentials
Review camera, face, location and spatial-map data flows. Configuration embedded in an app is extractable; privileged server credentials must not be treated as safe because they came from an environment file.
Release requirements
Check camera purpose text, permissions, privacy disclosures, age/safety requirements and store submission responsibilities. Passing local tests does not establish store 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.
ARKit
Role to evaluate: Apple AR provider; required configuration and optional features need supported-device checks.. 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.
ARCore
Role to evaluate: Android AR provider; depth/cloud features have separate support and network requirements.. 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 AR Foundation
Role to evaluate: Cross-platform AR SDK layer. 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.
Vuforia
Role to evaluate: Image/VuMark tracking ยท recognition. 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.
WebXR / WebAR
Role to evaluate: Browser AR route only where required APIs, permissions and device capabilities are supported.. 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.
RealityKit
Role to evaluate: Swift AR ยท animations ยท physics. 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.
SceneKit
Role to evaluate: Existing Apple 3D project maintenance route; verify current platform guidance before choosing new work.. 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.
Blender
Role to evaluate: 3D modeling ยท rigging ยท animation. 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.
Maya
Role to evaluate: High-poly modeling ยท baking. 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.
USDZ / glTF
Role to evaluate: AR asset formats ยท Quick Look. 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.
C# / Unity
Role to evaluate: AR logic ยท scripting. 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.
Swift
Role to evaluate: Native ARKit ยท RealityKit code. 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.
Kotlin
Role to evaluate: Native ARCore ยท SceneView code. 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.
Metal
Role to evaluate: Apple graphics backend where supported by the selected engine/provider.. 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.
OpenGL ES
Role to evaluate: Graphics backend only where supported by the pinned target/toolchain; not a universal Android requirement.. 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 / AWS
Role to evaluate: Backend ยท asset hosting ยท 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.
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 AR App 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 product-placement brief asks shoppers to inspect scale and finishes in their own room while keeping a normal product page usable. The challenge is aligning assets, camera permission, supported devices, surface discovery and commerce without implying that a visual preview guarantees physical fit.
A proposed implementation to test
A proposed design can load optimized models, show scanning guidance, place content after an accepted hit and let the user reset or adjust it. Keep authoritative product dimensions and prices outside the AR scene. Test dark rooms, reflective surfaces, refused permission, unsupported depth, changed orientation, tracking loss and network interruption. If the task cannot be supported, retain dimensions, imagery and an accessible non-AR route.
Acceptance and unresolved evidence
No delivery, sales improvement or customer reference is established by this example. Ask which assets and device results are available for inspection and which remain proposed. Define acceptance around scale calibration, placement/recovery behavior, content loading and documented limitations, not a universal smoothness or conversion claim.
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 AR App Development.
Can AR experiences feel genuinely native on iOS and Android?
AR can be designed to fit native input and lifecycle patterns, but tracking and feature support vary by device and provider. Inspect the required task on real target phones with the actual assets, permission flow and fallback. A shared SDK does not establish identical behavior.
How much does AR app 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.
How long does it take to build an AR app with Omnistu?
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.
Does an AR app require users to have special hardware?
Not every task requires dedicated depth hardware, but every AR mode has a supported-device/capability requirement. Check provider device lists and runtime support. Scope LiDAR, depth, reconstruction or face/body features separately, with a non-AR path when unavailable.
ARKit vs ARCore vs WebAR - which should I choose for my AR project?
Choose by distribution, devices, tracking features and integration needs. ARKit/RealityKit can suit Apple-specific scope; ARCore covers supported Android devices; AR Foundation shares selected logic across provider plug-ins; WebAR needs its own browser/capability validation. Verify feature parity rather than promise it.
What kind of 3D assets do I need for an AR app?
Provide source CAD, Blender, Maya or other licensed model files where available, with dimensions, units, pivots, material references and required variants. Agree conversion, geometry reduction, texture compression, LODs, USDZ/glTF outputs and the rights to redistribute each asset.
Can AR experiences work offline or with poor connectivity?
Offline behavior depends on the feature and packaged assets. Local tracking may work without a continuous connection once prerequisites are met, but cloud/shared/geospatial functions can need network services. Google explicitly requires internet for Cloud Anchor hosting and resolving. Test cold start and reconnection, not only a cached demo.
How does Omnistu measure AR tracking quality and performance?
Define a repeatable environment/device test matrix. Measure initialization, discovery, drift, relocalization, occlusion, frame time, memory and thermal behavior. Include tracking loss and recovery with production assets. Keep recordings and measurements with the accepted build.
What is the difference between AR, VR, and MR at Omnistu?
AR overlays content on a camera/world view; VR presents an immersive simulated environment; mixed-reality scope can blend spatial understanding, passthrough and interaction. These labels do not define supported hardware, safety or feature parity. Write the task and input/display capabilities explicitly.
Can Omnistu build an iPhone-only app with ARKit?
An iPhone-only route can be scoped using ARKit and RealityKit with a named supported-device matrix. Check configuration support and optional capabilities at runtime, and plan for permissions, interruptions and non-AR access. Do not assume every iPhone has LiDAR or the same tracking features.
Can you add AR to our existing app?
Start with an audit of the current app, source rights, navigation, rendering, camera use and native build tooling. Choose a maintained integration route and test lifecycle, permissions, memory and return-to-app behavior. Keep the existing non-AR workflow working during rollout.
Do AR apps work indoors, where GPS is unreliable?
Indoor AR can use mapped/image references, local or shared anchors and other positioning inputs, but requires a site-specific plan. GPS alone is not an indoor route solution. Verify map upkeep, relocalization, floor transitions, connectivity, accessible alternatives and safe guidance when confidence is low.
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 โ