Hire ARCore Developers: Skills, Cost & Engagement Models

To hire ARCore developers well, match the SDK skills to your actual feature set: ARCore is Google’s augmented reality platform for Android and cross-platform apps, and the developer you need depends on whether your project uses basic plane detection or the advanced Depth, Geospatial, and Cloud Anchors APIs. This guide covers the skills to require, how to vet them, 2026 rates, and the freelance-versus-agency-versus-in-house decision.

Most hiring content treats “ARCore developer” as one role. It is not. The single most expensive mistake buyers make is matching specialization to the wrong problem, hiring a Geospatial API specialist for a face-filter app, or a plane-detection generalist for a multi-user Cloud Anchors build. Scope the APIs first. Then hire to them.

Key Takeaways

• ARCore, released by Google on February 23, 2018, runs on Android 7.0 and above; a specialist hire is justified once your app uses Depth, Geospatial, or Cloud Anchors APIs.
• Vetted ARCore freelancers charge $60–$100+/hour on Arc.dev; US contract rates run $110–$185/hour for mid-level developers in 2026, per KORE1.
• Most ARCore work ships through Unity AR Foundation, so decide early whether you need a native Android specialist or a cross-platform Unity developer.
• A shipped Play Store app using the exact APIs you need is the only portfolio proof that counts; demos on a single device are not.
• Android device fragmentation is a real line item. Budget 2–4 weeks for testing across certified hardware before launch.

What APIs Make Up the ARCore SDK, and Which Require a Specialist?

The ARCore SDK is a set of augmented reality APIs from Google, and they split cleanly into two tiers: table-stakes capabilities any competent Android developer can integrate, and advanced APIs that demand production experience. Knowing which tier your project needs is the first step in writing a job description that filters correctly. ARCore supports Android (Kotlin/Java and C NDK), Unity via AR Foundation, Unreal Engine, iOS via ARCore Extensions, and WebXR, per Google’s ARCore documentation.

Core ARCore Capabilities Every Competent Developer Handles

Every ARCore developer should handle the SDK’s foundational APIs: motion tracking through simultaneous localization and mapping (SLAM), plane detection, light estimation, Instant Placement, Augmented Images, and Augmented Faces. These are the building blocks of any mobile AR app. Motion tracking keeps virtual objects fixed in space as the camera moves. Plane detection finds floors, tables, and walls. Light estimation matches virtual lighting to the real room.

ARCore requires Android 7.0 (API level 24) or higher and Android Studio 3.1 or higher, and the current release, ARCore v1.56.0, targets Android API level 37, according to Google’s ARCore release notes. A developer who cannot walk you through all six core capabilities and name the Android version floor is not ready for production work. These are the entry ticket, not the differentiator.

Advanced APIs That Separate Specialists from Generalists

The advanced ARCore APIs are where real product value and real hiring risk live: the Depth API, the Geospatial API, Cloud Anchors, and Scene Semantics. Each one is a distinct skill with its own failure modes, and experience with one does not imply experience with the others. This tier is what separates a specialist from a generalist.

The Depth API drives occlusion, letting virtual objects hide convincingly behind real furniture. Its Geospatial Depth mode extends range to 65 meters by combining device-motion depth with Streetscape Geometry data when a device sits in an area with Visual Positioning Service (VPS) coverage, per Google. The Geospatial API anchors content to GPS coordinates using Google’s VPS. Cloud Anchors handle persistence and multi-user sharing.

Here is the part job descriptions usually miss: these advanced APIs are not interchangeable competencies. A developer who shipped a Geospatial wayfinding app may have never touched Cloud Anchors, and asking them to build persistent multi-user AR is a different project with a different learning curve. Supporting tools like Filament, TensorFlow Lite, and MediaPipe often round out a senior candidate’s stack.

What Skills Should an ARCore Developer Have in 2026?

An ARCore developer in 2026 needs one of two skill profiles, and you must decide which before you post the role: native Android development in Kotlin, or cross-platform work through Unity AR Foundation. The two paths require different people, and conflating them produces bad hires. Below are the concrete competencies each path demands and the signals that separate a specialist from a general mobile developer.

Native Android Skills: Kotlin, Android Studio, and the Device Matrix

A native ARCore developer works primarily in Kotlin (now preferred over Java), Jetpack Compose, and Android Studio, with a solid grasp of the Android SDK lifecycle. That much any good Android engineer offers. The ARCore-specific skill is graphics and performance work: Vulkan and OpenGL ES rendering, glTF 2.0 asset pipelines, and holding a steady 60 frames per second on mid-range hardware.

In our ARCore work at Frame Sixty, an AR/VR and spatial computing development studio, device fragmentation is the overhead that shapes staffing. We maintain a device test matrix spanning ARCore-certified hardware from Samsung, Google Pixel, OnePlus, and Xiaomi, because tracking quality and camera behavior vary across chipsets and sensor configurations. A developer who has only demoed on a single Pixel has not met this problem. One who has shipped to a diverse Play Store audience has debugged it on a Friday night, and that experience is the thing worth paying for.

Cross-Platform Path: Unity AR Foundation and When It’s Sufficient

Most ARCore projects ship through Unity AR Foundation rather than native Kotlin, so a Unity developer who knows AR Foundation can often cover the role. ARCore v1.48.0 delivered full support for Unity 6 and AR Foundation 6, per Google’s release notes, and a single AR Foundation codebase can target both ARCore on Android and ARKit on iOS. For most consumer apps and cross-platform enterprise tools, this is the efficient hire.

Native Kotlin and ARCore expertise becomes necessary in narrower cases: when Google Play Services for AR integration must be customized, when Vulkan rendering sits at the center of the experience, or when C NDK interop is required for performance. If your project is cross-platform from day one, start with the Unity route and consider our guide to hiring Unity developers for the engine-side skills. The wrong call here means paying for a native specialist to do work Unity would have handled in half the time.

When Do You Need a Dedicated ARCore Specialist?

You need a dedicated ARCore specialist when your project depends on the SDK’s advanced APIs or on broad Android device coverage; otherwise a generalist AR developer will serve. The decision turns on specific trigger conditions, not on prestige. For readers still deciding between ARCore, ARKit, and a platform-agnostic approach, our broader guide on how to hire an augmented reality developer maps the full landscape before you narrow to ARCore.

Builds That Require an ARCore Specialist

Certain ARCore builds genuinely require a specialist with shipped production experience. Treat any one of these as a specialist indicator:

1. Depth API and occlusion — virtual objects must convincingly disappear behind real-world surfaces.
2. Geospatial API and VPS — AR content anchored to GPS coordinates with Street View-grade positioning.
3. Cloud Anchors — persistent, multi-user AR that survives app restarts and syncs across devices.
4. Scene Semantics — classifying scene elements like sky, floor, and plants to drive conditional AR behavior.
5. Wide Play Store distribution — shipping to a broad, fragmented Android device range that demands disciplined testing.

As a benchmark for this tier, Volpis screens ARCore candidates for five or more years of AR experience with shipped native Android apps and hands-on use of the Depth API, Geospatial API, and face tracking.

When a Generalist AR Developer Is Enough

A generalist AR developer is enough when your feature set stays inside ARCore’s core capabilities: plane detection, basic anchor placement, image tracking, and face filters cover the majority of mobile AR use cases. Not every project needs five years of Depth API work. If the scope is narrow and the budget is tight, over-hiring wastes money.

A Unity developer with solid ARCore and ARKit experience can usually carry a cross-platform consumer app without native ARCore specialization. Match the hire to the ceiling of your feature set, not to the most impressive resume in the stack.

How to Vet an ARCore Developer’s Portfolio and Technical Depth

Vet ARCore developers against one standard: a shipped, reviewed, production app on the Google Play Store that uses the exact APIs your project needs. Everything else, including GitHub demos, spec sheets, and raw years of experience, is a proxy for that proof. The goal of vetting is to replace proxies with evidence.

Portfolio Signals That Confirm Production Experience

Strong ARCore portfolios share verifiable traits. Look for live Play Store apps with real download counts, ratings, and recent update dates, not private repositories. Confirm the app actually uses the APIs you care about: install it and test Depth API occlusion or a Geospatial feature on your own device. Look for evidence of multi-device testing, such as a published device support list or beta feedback referencing different Android models.

The red flags are just as telling. Be cautious of a portfolio that lives only on GitHub with nothing published, demos recorded on a single device, or a candidate who cannot state the Android version floor and target API level of their shipped work. A developer who has truly shipped ARCore to production talks about device-specific bugs unprompted, because those bugs cost them sleep.

Technical Screen Questions and Tasks That Reveal Real Depth

A good technical screen for ARCore surfaces depth quickly through targeted questions and a short build task. Three questions do most of the filtering:

• Ask how they approach ARCore device fragmentation testing. A specialist names specific devices and chipset edge cases across Samsung, Pixel, and OnePlus hardware rather than saying “I test on a few phones.”
• Ask how they would build persistent AR for multiple simultaneous users in one room. The correct answer involves Cloud Anchors, the active internet requirement, and sufficient environmental features for 3D mapping.
• Ask about the Geospatial Depth API range limit and what activates it. The correct answer is 65 meters, with Streetscape Geometry enabled and VPS coverage present.

The strongest filter is a paid four-hour on-device build task, such as a small Depth API occlusion integration or a Cloud Anchor session. Resume inflators stall on real hardware. Shippers do not.

Need help scoping your ARCore project?

We are here to help!

Get in Touch

ARCore vs. ARKit: What the Difference Means When You Hire

ARCore and ARKit are the Android and Apple augmented reality SDKs respectively, and the difference reshapes your hiring budget, your testing burden, and your platform reach. ARCore is Google’s cross-platform SDK; ARKit is Apple’s iOS-only framework. For a hiring manager, the practical contrasts matter more than the API internals.

Factor	ARCore (Google)	ARKit (Apple)
Primary platform	Android 7.0+	iOS and iPadOS
Cross-platform reach	Android, plus iOS via ARCore Extensions and WebXR	iOS ecosystem only
Device testing burden	High — fragmented certified-device range	Low — controlled Apple hardware
Typical US senior rate	At or below senior ARKit rates	$140–$200+/hour
Unity support	AR Foundation 6 (Unity 6)	AR Foundation 6 (Unity 6)

The rate line deserves a note. Senior ARKit developers in the US run $140–$200+/hour, and ARCore Android specialists tend to sit at or slightly below that, because ARKit increasingly carries a visionOS and Apple spatial-computing premium that ARCore does not. If your product must reach both platforms, Unity AR Foundation covers both SDKs from one codebase. For the Apple side of this decision, see our companion guide to hiring ARKit developers, and for the engine-first route, our Unity developer hiring guide covers cross-platform staffing.

Freelance, Agency, or In-House: Which Engagement Model Fits Your ARCore Project?

The right engagement model for an ARCore project depends on scope and permanence: most ARCore work needs a specialist for a defined scope, not a full-time hire. Freelance suits narrow features, an agency suits full builds with accountability, and in-house suits companies where AR is the core product. The table below compares the three on the factors that actually drive the decision.

Factor	Freelance	Agency	In-House
Cost	$60–$100+/hr vetted (Arc.dev)	$25–$50/hr nearshore; $110–$185/hr US contract	$115K–$310K/year
Time to start	~72 hours	2–4 weeks	5–10 weeks
Device testing	Client-coordinated	Team + QA included	Owned internally
Accountability	Single developer	Studio owns delivery	Full control
Best fit	MVP, one feature	Full or multi-platform build	AR is core product

Freelance platforms move fast. Arc.dev vets ARCore freelancers down to the top 2% of applicants and can place one in roughly 72 hours, while bidding marketplaces like Upwork and Fiverr list developers from $10/hour with no quality guarantee. Nearshore agencies such as OGD Solutions match ARCore developers in one to two days at $25–$50/hour with a minimum of three years’ experience. If you expect to use a recruiter for a permanent hire, note that direct-hire placement fees run 20–25% of first-year base salary, per KORE1. For a full-service build rather than individual developers, our guide to the top AR app development companies lays out how to compare studios.

ARCore Developer Rates and Project Timelines in 2026

ARCore developer rates in 2026 range from roughly $10/hour on open marketplaces to $280/hour for senior US contractors, and project timelines run from six weeks for a simple app to twenty weeks for a Geospatial or Cloud Anchors build. Both numbers depend heavily on engagement model, geography, and API complexity. Ahrefs reports no reliable cost-per-click data for this keyword, so the figures below come from hiring-market sources rather than ad benchmarks.

Rate Ranges by Hiring Model and Region

ARCore rates sort into three tiers by sourcing channel. On open marketplaces, developers start around $10/hour but quality is unvetted; on curated platforms, Arc.dev lists vetted ARCore freelancers at $60–$100+/hour. Nearshore and offshore agencies land in the middle: Volpis averages $30–$40/hour across a full ARCore stack, and OGD Solutions quotes $25–$50/hour.

US-based talent commands the premium. According to KORE1’s 2026 hiring data, mid-level AR/VR developers run $110–$185/hour on W2 contracts and senior developers $185–$280/hour, while full-time Computer Vision/SLAM specialists earn $175,000–$225,000 at mid-level and $235,000–$310,000 at senior level. Offshore figures sit far lower; Flexiple’s talent database records median AR specialist rates near $6/hour for offshore contractors as of August 2026. Pay the rate that matches your API tier, not the lowest number you can find.

Typical Project Timelines: Prototype to Production

ARCore project timelines break into four stages, and the total runs six to twenty weeks depending on which APIs you use. The stages are predictable:

1. Discovery and scope — 1 to 2 weeks to define features, platforms, and the device matrix.
2. Environment setup — about 1 week for tooling, project scaffolding, and the test-device plan.
3. Core feature development — 4 to 12 weeks; basic plane detection sits at the short end, Geospatial and Cloud Anchors at the long end.
4. Testing and submission — 2 to 4 weeks for device fragmentation testing and Play Store review.

A straightforward ARCore app lands in six to ten weeks. A production build leaning on Geospatial or Cloud Anchors runs twelve to twenty. Agencies typically own all four stages; a freelance hire usually leaves discovery, coordination, and submission to you. For an end-to-end engagement from design through launch, see our AR app development services.

What the SERP Won’t Tell You About Hiring ARCore Developers

The competing pages ranking for this query list skills and quote rates, but they skip the judgment calls that decide whether an ARCore hire succeeds. Three of those calls matter most, and none of them show up in a typical freelancer listing or SDK document.

First, Android device fragmentation is a hidden cost, not a footnote. The mobile AR market was valued at $19.4 billion in 2025 and is projected to reach $23.5 billion in 2026, according to Global Market Insights, and most of that demand runs on a sprawling range of Android hardware. A developer who tested only on a Pixel will ship tracking bugs on mid-range Samsung devices. Write device testing into the contract as its own deliverable with its own weeks.

Second, the native-versus-Unity question is a seniority test in disguise. In our AR practice at Frame Sixty, the developers we trust to scope a project can explain exactly when native Kotlin and ARCore are required and when Unity AR Foundation is the faster, cheaper path to the same result. A candidate who defaults to one answer for every project, in either direction, has not shipped across enough constraints to make the call. That judgment, more than any single API, is what distinguishes a senior ARCore hire.

Third, specialization match beats rate shopping. As Google’s ARCore documentation puts it, “Cloud Anchors are special anchors hosted on the ARCore API cloud endpoint that persist AR experiences in the real world and enable shared experiences across multiple users and devices” — a capability with nothing in common with a face-filter build. Hiring the Cloud Anchors specialist for the filter app, or the reverse, wastes money no hourly rate can recover. ARCore’s five core pillars, documented since its February 2018 launch on Wikipedia, are a floor; the specialist tier is where scoping discipline pays off. If your project targets headsets rather than phones, our guide to Android XR development covers that adjacent decision, and our overview of augmented reality mobile app development frames the broader framework choice.

Conclusion

Hiring ARCore developers comes down to one discipline: scope the APIs before you scope the person. ARCore’s core capabilities are table stakes any competent Android or Unity developer can meet, but the Depth, Geospatial, and Cloud Anchors APIs demand specialists with shipped, verifiable production work. The most expensive hiring mistake is not overpaying; it is matching the wrong specialization to the problem, and no rate negotiation fixes that.

Rates in 2026 span a wide range, from offshore contractors near $6/hour to senior US developers at $280/hour, and the right number is the one that matches your feature tier and testing burden. Budget for Android device fragmentation as a real deliverable. Decide the native-versus-Unity question early, because it changes who you hire and how much you pay. Then verify every claim against a live Play Store app, not a demo reel.

Frame Sixty builds ARCore and cross-platform AR across Android, iOS, and headset platforms, and we help teams scope the specialization they actually need before a line of code is written. If you’d like to plan an ARCore project or evaluate candidates for your own team, reach out to us at Frame Sixty. You can also explore our work as an augmented reality agency, our full XR development services, or our guide to developing an augmented reality app from first concept to launch.