Remote Mac Rentals for QA and Device Testing

A persistent QA Mac accumulates state. After a few sprints it carries stale preferences, left-over test accounts, old simulator runtimes, cached network responses, and leftover build artifacts. When a test fails you spend as much time ruling the machine out as investigating the actual bug. Renting a remote Mac that you reset between cycles eliminates most of that overhead—you provision, test, capture evidence, and start the next cycle from the same baseline.

If you are evaluating Figment for this workflow, the short answer: start with an M-series Mac from $95/month (request-based; exact chip/RAM/disk confirmed in the quote) for interactive QA plus a Managed Build Mac at $249/month if you also want a maintained CI runner with backups, monitoring, and 30 minutes of monthly support. The $29 virtual Intel macOS plan runs real Intel macOS and can execute compatible Intel Xcode 26-or-earlier toolchains for cross-compiling and signing, but it is not an Apple silicon Mac—no ARM execution, no GPU acceleration, no audio.

Why Persistent QA Machines Accumulate Harmful State

macOS carries state across test runs in ways that are easy to miss:

• Keychain entries: credentials stored during one app session persist for later tests to find.
• Simulator state: iOS Simulator keeps installed apps, photos, and settings between launches unless explicitly erased.
• System preferences: a test that flips accessibility settings, notification permissions, or the default browser leaves those for the next tester.
• Library artefacts: crash logs, app containers, and cached assets pile up in ~/Library.
• Network overrides: edits to /etc/hosts or DNS caches can keep redirecting after the test ends.

Partial cleanup is scriptable—xcrun simctl erase all, targeted defaults delete, Keychain item removal—but a reset remote machine saves you from having to prove the cleanup was complete.

Rental Cost vs. a Physical Lab Mac

A lab Mac mini costs roughly $800–$1,500 up-front plus space, power, networking, and someone to keep it patched. It depreciates over three to five years, and testing against multiple macOS versions multiplies the hardware count.

Rentals are billed monthly. Published Figment prices: $29/month virtual Intel macOS (2 vCPU, 8 GiB RAM, 80 GiB disk), $49/month i3 Mac (request-based), M-series from $95/month (request-based), Managed Build Mac $249/month (one M-series Mac, CI setup, backups, monitoring, 30 minutes monthly support). Details and quotes at /mac-hosting.

A sanity check against one external provider: CloudMac lists an M4 with 16 GB / 256 GB at $99.99/month and $999/year, which works out to roughly $83.25/month on the annual plan—cheaper on paper than twelve months of Figment's $95 entry if you only need that specific M4 configuration and are comfortable prepaying a year. Figment's $95 is an M-series entry price, not a confirmed M4/16 GB spec; ask for the quote if the chip and memory matter to your tests. Figment's differentiator at $249 is the specific managed CI work (pipeline setup, backups, monitoring, support hours), not the raw hardware.

Plans are billed monthly. A two-week cycle still costs the full month. The table compares list prices only; taxes and fees are as stated in the actual offer.

Provisioning a Baseline via Bootstrap Script

Run this on a freshly delivered rental—paste it into the browser-console terminal on the virtual Intel plan, or into Terminal over the physical machine's configured remote-access method—to bring every cycle to the same starting state. Replace the artifact URL and app name with your project's actual values.

#!/bin/bash
# baseline.sh — run on a fresh Mac rental after first login.
# Usage: bash baseline.sh <app-version>
set -euo pipefail

APP_VERSION="${1:?Usage: baseline.sh <app-version>}"
EVIDENCE_DIR="${HOME}/Desktop/qa-evidence-$(date +%Y%m%d-%H%M%S)"
mkdir -p "${EVIDENCE_DIR}"

# Install Homebrew if absent
if ! command -v brew >/dev/null 2>&1; then
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
fi

brew install --quiet xcbeautify jq

# Reset simulators if Xcode is installed on this plan
if command -v xcrun >/dev/null 2>&1 && xcrun simctl help >/dev/null 2>&1; then
  xcrun simctl shutdown all || true
  xcrun simctl erase all
fi

# Download and install the target build
BUILD_URL="https://artifacts.example.com/builds/${APP_VERSION}/YourApp.pkg"
curl -fsSL "${BUILD_URL}" -o "/tmp/YourApp-${APP_VERSION}.pkg"
sudo installer -pkg "/tmp/YourApp-${APP_VERSION}.pkg" -target /

# Record baseline metadata
{
  sw_vers
  echo "App version requested: ${APP_VERSION}"
  /usr/bin/defaults read /Applications/YourApp.app/Contents/Info CFBundleShortVersionString 2>/dev/null || true
} > "${EVIDENCE_DIR}/baseline.txt"

echo "Baseline complete. Evidence dir: ${EVIDENCE_DIR}"

This is an unexecuted example, not a benchmark. Run it on your own project and check the output. The virtual Intel plan ships without Xcode by default, so the xcrun block is a no-op unless you add Xcode (and the right Xcode 26-or-earlier release that supports Intel; see Apple's porting your macOS apps to Apple silicon for the Intel/ARM boundary).

Connecting the Tester via Screen Sharing

For interactive and exploratory testing, connect using the built-in macOS Screen Sharing feature documented in Apple's Share the screen of another Mac. Enable it on the rental under System Settings → General → Sharing → Screen Sharing. On the virtual Intel plan the primary access path is the browser console; graphical access is available in the desktop session, inbound SSH is not provided.

Give the tester a Standard user account rather than Administrator—per Apple's user accounts documentation, Standard accounts can change their own settings but cannot add users or alter system-level preferences, which keeps the baseline stable during the session. Start a screen recording from Control Centre → Screen Recording → Record Entire Screen before the test begins so evidence capture is not dependent on the tester's memory.

QA Session Template

Copy this into your bug tracker before each cycle.

Pre-test baseline checklist

• Fresh rental provisioned; hostname and macOS version recorded
• baseline.sh <app-version> finished without errors
• Installed app version matches the ticket's build tag
• No leftover test data (spot-check Keychain and ~/Library/Containers)
• Screen resolution set to the test spec
• Screen Sharing confirmed; screen recording started

Test execution log row

Run ID:   QA-{YYYYMMDD}-{tester initials}
Host:     {rental hostname}  macOS {version}  App {build}
TC-{id} | {title}
Steps:    1. … 2. …
Expected: …
Actual:   …
Status:   PASS / FAIL / BLOCKED
Evidence: {screenshot filename or recording timestamp}

Post-run teardown

• Stop recording; confirm file saved under the evidence dir
• Upload recording and screenshots to your artifact store
• File a bug with repro steps for each FAIL, including macOS and build
• Export the execution log to the shared tracker
• Note any system anomalies (panics, reboots, unexpected prompts)
• Export anything you need off the machine before the plan ends

Exporting Evidence Before Teardown

Export before you cancel. Confirm with support whether any post-cancellation retrieval window applies to your plan; do not rely on it.

tar -czf "${HOME}/Desktop/qa-evidence-$(date +%Y%m%d).tar.gz" \
    "${HOME}/Desktop/qa-evidence-"*/
# Then upload with your configured CLI, for example:
#   aws s3 cp <archive> s3://your-bucket/qa-runs/
#   rclone copy <archive> remote:qa-runs/

On the virtual Intel plan install and authenticate your sync CLI (aws, rclone, gcloud) as part of baseline.sh so the teardown step has somewhere to push.

Request an i3 or M-series Mac for your next QA cycle at /mac-hosting, or start a configuration request at /mac-hosting/start.

Related guides:

• Remote Mac support session guide
• Remote Mac contractor setup
• GitHub Actions self-hosted runner on a Mac