AWS Device Farm Pricing: Only Flat-Rate Option

AWS Device Farm offers real device testing integrated with the AWS ecosystem. For teams already on AWS, it’s a natural fit. But the pricing model and limitations aren’t always obvious.

This guide breaks down what you’ll actually pay, the 150-minute hard limit that catches teams off guard, and when AWS Device Farm makes sense versus alternatives. For a head-to-head comparison, see AWS Device Farm vs BrowserStack.

Pricing Structure

AWS Device Farm uses two pricing models:

Pay-As-You-Go (Metered)

A “device minute” includes the time to install your app, execute tests, and uninstall. The clock runs from device preparation to teardown.

Example costs:

• 500 minutes/month = $85
• 1,500 minutes/month = $255
• 3,000 minutes/month = $510
• 5,000 minutes/month = $850

Unmetered Plans

Unmetered means unlimited testing for that slot. A slot equals one concurrent device. Buy 10 Android slots and you can run 10 devices in parallel, but you’re capped at 10 concurrent jobs regardless of total test volume.

The breakeven point:

At $0.17/minute, you hit $250 at approximately 1,470 minutes. If you’re consistently above 1,500 minutes/month per slot, unmetered wins.

The 150-Minute Hard Limit

Here’s what trips up teams: AWS Device Farm has a 150-minute hard limit per test run. This cannot be extended.

From AWS documentation:

“There is a 150-minute hard limit to the duration of an automated test run.”

If your test suite takes longer than 2.5 hours, it will be forcibly stopped. Partial results may be available, but you’re billed for execution up to that point.

Who This Affects

Teams with:

• Large E2E test suites (common in enterprise apps)
• Slow test execution (complex UI flows, heavy data setup)
• Multiple app variants tested sequentially
• Performance/load testing that requires sustained execution

Workarounds

1. Split your test suite

Instead of running 300 tests in one job, split into 3 jobs of 100 tests each. Each job gets its own 150-minute window.

# Example: Parallel test execution across Device Farm
import boto3

client = boto3.client('devicefarm')

# Split tests into chunks
test_chunks = [tests[i:i+100] for i in range(0, len(tests), 100)]

# Submit each chunk as a separate run
for chunk in test_chunks:
    client.schedule_run(
        projectArn=project_arn,
        appArn=app_arn,
        devicePoolArn=device_pool_arn,
        test={'type': 'APPIUM_JAVA_JUNIT', 'testPackageArn': test_package_arn}
    )

2. Use custom test environments

AWS custom test environments run tests more similarly to local environments and can execute faster than the standard environment.

3. Optimize test execution time

• Parallelize tests across devices (use more slots)
• Reduce unnecessary waits and sleeps
• Use efficient locators (ID > XPath)
• Minimize app reinstalls between tests

For more optimization tips, see Mobile Testing CI/CD Pipeline Optimization.

4. Set appropriate timeout buffers

The default timeout is 150 minutes. If your tests typically take 120 minutes, you’re cutting it close. Set a lower timeout (e.g., 140 minutes) to fail fast if something hangs rather than burning through the full window.

client.schedule_run(
    # ... other params
    executionConfiguration={
        'jobTimeoutMinutes': 140  # Fail before hitting 150-min limit
    }
)

Other Limitations

The 150-minute limit is the most impactful, but there are others:

Appium Command Timeout

Every Appium command has a 4-minute execution limit. Commands that take longer will fail. This affects:

• Large file uploads/downloads
• Complex gestures
• Heavy data operations

Data Security Concerns

From AWS’s own documentation:

“Data can persist between sessions… Data is not encrypted at rest.”

For teams handling sensitive data (healthcare, fintech), this is a red flag. AWS Device Farm is not in scope for most compliance certifications. You’re responsible for ensuring test data doesn’t include PII or sensitive information. For a deeper analysis, see AWS Device Farm Security.

iOS Limitations

• Entitlements stripped: iOS apps are re-signed during upload, which can remove certain entitlements
• Limited device selection: Fewer iOS devices than competitors
• Oregon-only: All devices are in US West (Oregon), adding latency for teams elsewhere

Job Limits

• Maximum 250 in-flight jobs across your account
• Default concurrency is 5 for metered, equal to purchased slots for unmetered

Cost Comparison: AWS vs Competitors

Note: BrowserStack/LambdaTest prices are for 1 parallel. They don’t have per-minute limits, so comparison isn’t apples-to-apples.

For detailed BrowserStack pricing, see BrowserStack Pricing 2026: Hidden Costs. For LambdaTest, see LambdaTest App Automation Pricing 2025. For a side-by-side view of all platforms, see our full cloud pricing comparison.

When AWS Wins

• Heavy usage (3,000+ minutes/month per slot)
• Already on AWS (IAM integration, single billing)
• Need deep AWS service integration
• Running automated tests in CI/CD (Jenkins plugin, Gradle plugin)

When Competitors Win

• Lighter usage (<1,500 minutes/month)
• Need more device coverage (BrowserStack has 30,000+ vs AWS’s 2,500)
• Test suites that run longer than 150 minutes
• Teams outside US West (latency matters)
• Compliance requirements (BrowserStack offers SOC2, etc.)

Real-World Cost Examples

Startup: 10 devices, moderate testing

Scenario: 200 tests, 5 minutes each, run 10x per month across 10 devices

• Per run: 10 devices × 5 min × 200 tests = 10,000 device minutes
• Monthly: 10,000 × 10 runs = 100,000 minutes
• Metered cost: $17,000/month (ouch)
• Unmetered cost: 10 slots × $250 = $2,500/month

For heavy users, unmetered is the only sensible option.

Mid-size team: 5 devices, daily smoke tests

Scenario: 50 tests, 2 minutes each, run daily across 5 devices

• Per run: 5 devices × 2 min × 50 tests = 500 device minutes
• Monthly: 500 × 30 days = 15,000 minutes
• Metered cost: $2,550/month
• Unmetered cost: 5 slots × $250 = $1,250/month

Breakeven is around 1,470 minutes per slot. At 3,000 minutes/slot/month, unmetered saves 50%.

Enterprise: 20 devices, full regression

Scenario: 500 tests, 3 minutes each, run 5x per week across 20 devices

• Per run: 20 devices × 3 min × 500 tests = 30,000 device minutes
• Monthly: 30,000 × 20 runs = 600,000 minutes
• Metered cost: $102,000/month (not viable)
• Unmetered cost: 20 slots × $250 = $5,000/month

At enterprise scale, unmetered is 20x cheaper.

Private Devices

For teams needing dedicated hardware:

Private devices are exclusive to your account. No sharing, no data persistence from other users. They’re useful for:

• Security-sensitive testing
• Custom device configurations
• Consistent test environments

Integration Advantages

If you’re on AWS, Device Farm integrates cleanly:

• IAM: Use existing AWS credentials
• CodePipeline/CodeBuild: Native integration
• S3: Direct artifact storage
• CloudWatch: Centralized logging
• Single invoice: Consolidated AWS billing

The Jenkins and Gradle plugins make CI/CD integration straightforward:

// Gradle plugin example
devicefarm {
    projectName "MyProject"
    devicePool "Top Devices"
    appPath file("app/build/outputs/apk/debug/app-debug.apk")
    testPackagePath file("app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk")
}

Bottom Line

AWS Device Farm makes sense for:

• Heavy AWS users who want single-pane-of-glass
• Teams with test suites under 150 minutes
• High-volume testing where unmetered pricing wins
• CI/CD pipelines needing native AWS integration

Look elsewhere if:

• Your test suites exceed 150 minutes
• You need more than 2,500 devices
• You’re outside US West and latency matters
• Compliance requires encrypted data at rest
• You need fewer than 1,500 minutes/month (competitors are cheaper)

The 150-minute limit is the killer for many teams. If your regression suite can’t be split into 2.5-hour chunks, AWS Device Farm isn’t viable. That’s not a bug to work around—it’s a fundamental constraint of the platform.

For teams hitting these limits, consider BrowserStack or self-hosted device labs as alternatives.