What is the difference between a custom DPC and AMAPI?
Both architectures use an on-device Device Policy Controller. The decisive difference is who develops and maintains it, how instructions reach it, and who is responsible when enforcement fails.
What a custom DPC means in practice
A custom DPC is an Android application appointed as Device Owner or Profile Owner during provisioning. It talks to the EMM provider’s backend and translates management instructions into local Android policy operations. This gives the provider direct control, but also makes it responsible for authentication, reporting, offline behavior, updates, and compatibility across every supported Android and OEM release.
The control path remains entirely inside the provider’s product: the EMM backend sends an instruction through its communication layer, the DPC interprets it, and the DPC calls Android’s management APIs. When a policy does not apply or a controller update fails, diagnosis and recovery belong to the provider.
What changes with AMAPI
Android Management API is a Google-hosted service for EMM providers. The backend manages enterprises, policies, enrollment tokens, device records, and supported remote commands through AMAPI. During provisioning, Google’s Android Device Policy becomes Device Owner or Profile Owner and performs the local enforcement.
The EMM provider still owns the product experience, tenant model, administration, and customer workflows. What moves to Google is the standard Android controller and much of the work needed to keep that controller aligned with platform releases.
An AMAPI deployment can run a custom launcher, telemetry agent, hardware-integration service, or companion application alongside Android Device Policy. The supporting app receives only the permissions, roles, or delegated capabilities explicitly assigned to it.
Device Owner is powerful, but it is not root
Device Owner is Android’s strongest standard enterprise-management role, not unrestricted system authority. Proprietary firmware installation, protected hardware control, vendor partitions, or restricted system interfaces may still require an OEM SDK, privileged installation, platform signing, custom firmware, or explicit manufacturer support.
Which devices can each model support?
AMAPI is best suited to supported Google Mobile Services–enabled Android Enterprise devices.
“Supported” has three separate meanings. First, the Android build must implement Device Owner, Profile Owner, and every policy API the product needs. Second, the device must be eligible for the Google services on which Android Device Policy and managed Google Play depend. Third, the exact firmware must remain secure and operationally supportable for the expected fleet lifetime. Passing one test does not guarantee passing the other two.
| Deployment | AMAPI | Custom DPC | Practical conclusion |
|---|---|---|---|
| Personal device + work profile | Supported | Technically possible | AMAPI is the normal choice for a new Google-backed work profile. |
| Fully managed corporate device | Supported on eligible devices | Supported where Device Owner provisioning exists | Policy coverage, ecosystem eligibility, and customization decide. |
| Dedicated / kiosk device | Supported as fully managed | Supported, often with a custom launcher | AMAPI suits standardized GMS kiosks; custom matters for unusual local behavior. |
| Plain AOSP / non-GMS | Not a standard target | Potentially supported | Validate APIs, provisioning, distribution, updates, and recovery on the exact build. |
| Rugged enterprise device | Supported when Google services qualify | Supported | Check standard policy and OEMConfig before building a DPC. |
| OEM embedded product | Only if built as an eligible product | Often more flexible | OEM APIs, privileged apps, or firmware changes require manufacturer participation. |
Enrollment, provisioning, reset, and zero-touch
AMAPI standardizes the device-side lifecycle around Google-issued enrollment tokens and Android Device Policy. A custom DPC gives the provider more control and ownership of the registration protocol, identity binding, retries, reconciliation, and recovery.
Enrollment and provisioning are not the same event
Enrollment creates the relationship between a device, an enterprise, a user or asset, and an assigned policy. Provisioning is the broader on-device process: it installs or activates the DPC, assigns Device Owner or Profile Owner, creates a work profile where needed, establishes connectivity, registers the device, applies initial policy and applications, and completes the Android setup flow.
A DPC can be installed without a successful enrollment, and a backend can hold a device record even though local provisioning failed. Production systems need states and recovery paths for those partial outcomes.
Provisioning responsibility
With AMAPI, the EMM backend creates an enrollment token inside a specific enterprise. QR, enrollment link, sign-in, NFC, the Android Device Policy identifier, or zero-touch can begin the flow. Android Device Policy handles the standard device-side state machine, while the EMM remains responsible for deciding who may enroll, selecting the enterprise and policy, authenticating the installer, mapping the device to an asset, and presenting useful status and errors.
With a custom DPC, Android can assign the ownership role but does not provide the complete commercial enrollment protocol. The provider designs token validation, server discovery, tenant assignment, device authentication, credential rotation, acknowledgements, retries, cleanup, audit records, and reconciliation between local and backend state. That freedom also creates more ways to leave a device partially enrolled or attached to the wrong customer.
Enrollment tokens are credentials
Enrollment tokens should be short-lived and tenant-specific, with per-device tokens used when asset-level traceability matters. Record who generated and consumed each token, avoid displaying an issued credential again, and monitor reusable staging tokens for unexpected volume.
A QR payload, serial number, IMEI, or zero-touch extra is useful bootstrap data, but it is not durable proof of device identity. A stronger implementation uses the bootstrap only to establish the first authenticated session, then binds a protected and revocable device credential to the enrolled asset.
An eligible device still needs internet access at first boot to retrieve its assignment and DPC. Test captive portals, DNS and firewall restrictions, TLS inspection, incorrect clocks, unstable networks, and blocked Google services.
Erasure depends on ownership
A fully managed or dedicated company-owned device is normally erased by resetting the complete device. On a personally owned device, enterprise removal should delete the work profile and its managed data while leaving the personal profile intact. A company-owned device with a work profile may either relinquish ownership when transferred to an employee or be fully reset when reclaimed by the organization.
Factory Reset Protection and zero-touch solve different problems: FRP can require an authorized account after an untrusted reset, while zero-touch can reapply enterprise management during setup. Their interaction must be designed and tested.
Google approval, usage, and quota restrictions
A technical quickstart demonstrates basic API functionality, but it does not establish production readiness or authorize a commercial service. Since 1 November 2025, AMAPI device enrollment requires Android Enterprise registration and approval. Device quota is a separate capacity approval, while Google’s public EMM validation process requires implementation and review of the standard features of at least one Android Enterprise solution set. Advanced features are optional. Enrollment approval, Solution validation
Approval also creates a continuing product obligation. Approved EMMs must implement resulting changes to published feature requirements within 180 days to retain access to Android Enterprise services. This requirement concerns applicable solution-set requirements, not every newly released AMAPI feature. Google separately specifies 180 days after successful EMM Community registration to develop the solution, pass product review and deploy publicly. Teams should account for these requirements when planning review evidence, regression testing and customer rollout dates. Release and compatibility requirements
AMAPI is not a general-purpose internal device-control API
Google restricts AMAPI to eligible commercial EMM developers, Device Trust providers and Android OEMs. EMM providers must sell to customers outside their immediate company or parent, support them directly, maintain direct agreements and disclose service-data use. OEM use is limited to enabling EMM features for GMS compliance.
Prohibited uses include controlling device functionality according to financing payment status, exclusive monitoring or fingerprinting independent of enterprise management, and application deployment without express, informed prior consent from relevant customers and end users. Solutions developed and used exclusively for first-party in-house applications are also prohibited. These are selected restrictions; the full policy must be checked against the proposed business model. Permissible Usage policy
Customer consent creates product requirements
Customer consent creates product requirements when an EMM creates an enterprise and records acceptance of the Managed Google Play Agreement on a customer’s behalf. The EMM must obtain express consent, retain auditable acceptance records, collect required contact details and obtain the required consent to disclose them to Google. It must also support the specified DPO and EU-representative contact updates. When the customer relationship ends, the terms require advance notice followed by enterprise deletion. The implementation depends on the onboarding flow; Google also provides an administrator-completed signup process. API terms, Enterprise signup
Published capacity limits shape the architecture
As checked on 14 September 2026, Google documents:
- An initial quota request of up to 500 devices, requiring full business justification; exceeding 500 requires another application.
- A default quota of 1,000 queries per 100 seconds per project.
- 60 queries per minute for the same API action, EMM ID, enterprise ID and policy or device ID combination.
- Quota for at most two projects per developer, intended for development and production separation.
Google provides a process for requesting quota increases or restriction changes. Published quotas
The project limit constrains AMAPI quota allocation, rather than requiring all customer infrastructure to share one project. A shared AMAPI integration needs strong tenant-aware authorization and enterprise-to-customer mappings; customer databases, compute and storage can still be isolated separately. This is an architectural implication of the quota model, not a Google-prescribed hosting design.
The real development and operational costs
AMAPI usually costs less than an equivalent general-purpose custom DPC, but it does not make an MDM product turnkey. It transfers the common on-device controller and much of its Android-version maintenance to Google.
| Cost area | AMAPI | Custom DPC |
|---|---|---|
| On-device controller | Google maintains Android Device Policy. | You develop, sign, secure, test, and update the DPC. |
| Backend and policy | Build the commercial backend and translate product settings into AMAPI policy. | Also build the device protocol and map policies across Android and OEM versions. |
| Enrollment | Own authorization, token governance, identity, UX, and recovery around Google’s flow. | Also own bootstrap, DPC acquisition, registration, acknowledgements, and partial failures. |
| Command delivery | Standard delivery is handled through AMAPI and Android Device Policy. | Operate FCM, MQTT, polling, or another authenticated, retry-safe channel. |
| App distribution | Managed Google Play handles much of the standard lifecycle. | Non-GMS products may need a repository, CDN, signature checks, staging, and rollback. |
| Compatibility and incidents | Test real workflows and escalate controller defects to Google. | Own the expanding test matrix, controller fixes, release, and physical recovery risk. |
AMAPI still needs a production EMM around it
The remaining work spans customer administration, management workflows, service operations, and the customer lifecycle. The product still needs multitenancy, consent evidence, role-based access control, secure service credentials, policy rollout, enrollment governance, application configuration, inventory reconciliation, and command status.
Operationally, it also needs notification processing, deduplication, safe retries, dead-letter handling, quota monitoring, audit logs, reports, retention, offboarding, enterprise deletion, regression testing, and support procedures. A prototype hides much of this work because it manages one enterprise with broad permissions and assumes every request succeeds.
What a custom DPC adds
A custom implementation adds a privileged Android component and its full operating lifecycle. The provider must maintain reliable behavior through reboot, idle modes, and intermittent connectivity; detect Android and OEM capabilities; secure the command and update chain; protect signing keys and device credentials; stage releases; and recover devices that can no longer reconnect.
The highest costs are often deferred. A first version may work on the development device, while failures emerge after an OEM firmware update, a background-execution change, a signing problem, or an interrupted DPC update. Because Device Owner cannot be replaced like an ordinary application, software failure can become factory-reset or physical field work.
Total cost of ownership is initial engineering and validation, plus recurring maintenance, infrastructure, compatibility testing, support, security and compliance, and the expected cost of incidents and recovery.
Device count alone is a poor estimator. Fleet diversity, firmware branches, management modes, critical workflows, telemetry volume, and physical recovery exposure matter more. Five hundred identical kiosks on one controlled firmware can be cheaper to support than one hundred employee devices spread across several manufacturers and Android releases.
The decision rule
Choose a custom DPC only when all three conditions hold.
- 01
A required capability, device class, or offline/OEM workflow cannot be delivered through AMAPI, OEMConfig, or a managed companion app.
- 02
The fleet is sufficiently controlled—ideally known hardware and firmware with a predictable release lifecycle.
- 03
The measurable value exceeds the custom platform’s engineering, validation, support, and physical recovery premium.