From Order to First Build

Connect a Cloud Mac to Your Existing Development Workflow

This runbook starts with plan selection, then checks the node, connection credentials, toolchain, signing environment, and build artifacts. The goal is not simply to open the machine, but to complete a reproducible, reversible, fully logged real build on a dedicated physical Mac mini.

2 tiers Dedicated physical machine configurations
5 Available runtime nodes
$19.9/day Starting price
Cloud Mac network map connecting Singapore, Tokyo, Seoul, Hong Kong, and the U.S. West nodes Singapore South Korea (Seoul) Hong Kong U.S. West
Runbook First-build onboarding
Resources
Dedicated to a single order
Form factor
Physical node, not a virtual machine
Availability
Available 365 days a year
Before you run

Document these six inputs before choosing a plan

Choosing the wrong node or missing repository access usually takes longer to fix than installing the tools. Before ordering, add the information below to the team task ticket; assign an owner, define verification, and document the rollback path.

01 / Eligibility

Developer Program access

Confirm that the members responsible for signing and release have the required Developer Program access, and clarify who manages certificates, provisioning profiles, and the team identifier. Never put sensitive authentication data in ordinary chat messages or build logs.

Definition of done The owner can explain the source, validity scope, and renewal process for the signing materials.
02 / Code

Repository and dependency access

Check access to the main repository, submodules, private package sources, artifact repositories, and large-file storage one by one. CI machine credentials must be separate from personal credentials and limited to the minimum permissions required for the build.

Definition of done A clean environment can fetch the complete source and dependencies at their locked versions.
03 / Toolchain

Target Xcode version

Infer the Xcode version from the project configuration, target SDK, compiler requirements, and plugin compatibility. If the project has multiple release branches, record the Xcode and command-line tools version for each branch.

Definition of done The version number, rationale, and compatibility verification commands are documented.
04 / Node

Network route and node

Choose from Singapore, Japan (Tokyo), South Korea (Seoul), Hong Kong, and the U.S. West. Prioritize the network locations of your code source, dependency mirrors, and users—not geographic distance alone.

Definition of done The target node has been tested from the main office networks, with the network context recorded.
05 / Capacity

Working set and disk headroom

Measure peak usage across source code, dependency caches, DerivedData, archives, simulators, and logs. 256GB suits a controlled working set; large assets, multiple toolchain versions, or long-lived caches may require the 2TB configuration or an added storage option.

Definition of done The peak estimate includes temporary build files and reserves space for cleanup and exports.
06 / Duration

Task length and rental term

Choose a daily, weekly, monthly, or quarterly term for one-off troubleshooting, iteration sprints, continuous integration, or long-running experiments. Include setup, validation, and final data export time—not just compilation time.

Definition of done The end time, renewal checkpoint, and export owner are defined.
Configuration order

Verify in this order: model, node, term, billing

Before confirming an order, do not look only at the starting price. First confirm that the resources cover the peak working set, then verify the network route, and finally check every USD amount and optional add-on.

Device allocation Choose one dedicated physical Mac mini
USD billing
A

VMDebug M4

Suitable for standard Xcode builds, automated testing, and light-to-moderate cache sizes.

M4 16GB RAM 256GB SSD
Daily
$19.9
Weekly
$53.7
Monthly
$99.4
Quarterly
$270.4
Choose VMDebug M4
01 Model

Choose one of the two tiers based on peak memory, disk working set, and the number of parallel tasks.

02 Node

Choose one node from Singapore, Japan (Tokyo), South Korea (Seoul), Hong Kong, and the U.S. West.

03 Term

Choose daily, weekly, monthly, or quarterly, and ensure the end time covers environment validation and data export.

04 Confirm

Check the base model, node, term, and add-ons, confirm the final USD bill, and submit the order.

Payment and billing

Only USDT-TRC20 and Visa / Mastercard / Amex (via Stripe) are supported. All orders are billed in USD. Actual gateway availability is determined by the backend response.

Review the complete plan and add-ons
First connection

Verify your identity before transferring the project

After receiving the connection details, limit the first session to identity verification, credential updates, and a minimal connection test. If the host fingerprint does not match, stop connecting and verify it through a console support ticket; do not bypass the warning.

Connection checklist First SSH session
  1. 01

    Read the device information

    From the console order details, read the device ID, host address, port, username, and host fingerprint. Obtain these details only from the current order.

  2. 02

    Compare the host fingerprint

    The fingerprint shown on the first SSH connection must match the order details. Record the result in the internal runbook to distinguish expected changes from anomalous connections later.

  3. 03

    Update temporary credentials

    Change the temporary credentials immediately after the first login. Store them using the team-approved key-management method and confirm that the old credentials are no longer used for routine access.

  4. 04

    Complete both-channel testing

    Run SSH command and file read/write tests first, then check the macOS graphical interface connection if required by the project. Follow the support guide step by step to check the connection method and port.

ssh -p <port> <user>@<host>
uname -m
sw_vers
df -h /
xcode-select -p

Connection acceptance criteria

  • Fingerprint matches the order details
  • Temporary credentials have been updated
  • SSH commands return consistently
  • File uploads, downloads, and permissions work as expected
  • The graphical interface connection test result is recorded
Troubleshoot connection issues

Include this information when reporting an issue

Prepare the device ID, occurrence time and time zone, network provider, host-fingerprint comparison, reproduction steps, redacted logs, and troubleshooting actions already completed. Do not submit account passwords, wallet private keys, or full card numbers.

Open a console support ticket
Migration paths

Split the migration into reversible data, toolchain, and CI paths

Do not move everything at once and troubleshoot afterward. Define inputs, verification points, and rollback actions for each path; proceed only after each path passes, so network, dependency, and signing issues do not become mixed together.

PATH 01

Data migration

Migrate only the datasets required for the build. Avoid copying local caches, old archives, and unknown state into the new environment.

Input
Source code, required assets, configuration templates, dependency lockfiles, and redacted test data.
Verification point
Verify file counts and checksums; confirm permissions, symbolic links, line endings, and large-file objects are intact.
Rollback action
Keep a local read-only copy. If verification fails, clear the target directory and resync from the latest complete manifest.
PATH 02

Toolchain reproduction

Rebuild the environment from a version manifest instead of copying the entire local system state. Install required tools first, then restore project dependencies and caches layer by layer.

Input
Xcode version, command-line tools version, Brewfile, package-manager lockfiles, and certificate and Keychain import manifest.
Verification point
Record compiler, SDK, Git, Ruby, Node, and project dependency-resolution results, then run the smallest test target.
Rollback action
Keep the version manifest and installation logs. If a conflict occurs, remove items added in this pass and return to the last verified version set.
PATH 03

CI integration

Connect a single test branch to the runner first. After confirming isolation, caching, and log delivery, switch production jobs to the cloud Mac.

Input
Runner registration details, working-directory rules, secret-injection method, cache keys, failure retries, and artifact-upload strategy.
Verification point
Run clean and cached builds consecutively, checking exit codes, logs, artifact checksums, and directory isolation between tasks.
Rollback action
Keep the original runner available. If the new path fails, pause scheduling and restore the last verified job definition.
Switching condition
Switch long-running tasks only after all three paths pass

Expand branch coverage or task concurrency only after data checksums match, toolchain versions are reproducible, and CI builds are stable. During migration, do not change dependency versions, signing strategy, and scheduling method at the same time.

Environment initialization

Rebuild the development environment from version facts

Installation is not acceptance. After each configuration layer, record the resulting version, path, or permission so the next engineer can reproduce it from the same checklist.

Initialization record Recommended order
Reproducibility first
  1. 01

    Xcode and command-line tools

    Install the project-specified version and confirm the active developer directory, SDK list, and compiler version. When multiple versions coexist, put the switching command in the runbook.

  2. 02

    Git and repository access

    Set the commit identity, host verification, and least-privilege credentials. Then fetch the main repository, submodules, and large-file objects, and check the default branch and remote URL.

  3. 03

    Certificates and Keychain

    Import the required materials according to the team process, and check access controls and build-process read permissions. Sensitive content must not enter source code, ordinary logs, or shared caches.

  4. 04

    Package management and caches

    Restore dependencies from the lockfiles, distinguishing reusable caches from project state that must be regenerated. Cache keys should include toolchain and dependency versions.

  5. 05

    Build directories

    Set separate paths for source, DerivedData, archives, logs, and exported artifacts, and define cleanup and export rules for the end of a task.

Version capture

Save an environment fingerprint first

The output below can serve as the baseline for the first build. Add or remove commands according to the package managers actually used by the project; never write secrets or complete environment variables to logs.

sw_vers
uname -m
xcodebuild -version
xcode-select -p
git --version
ruby --version
node --version
df -h /
First-build acceptance

Prove the environment is deliverable with one complete pipeline run

A successful compile alone is not enough. First-run acceptance should cover dependency restoration, tests, archiving, signing checks, and artifact download, with duration, exit code, and log location tied to the same commit.

Cloud Mac first-build acceptance sequence and pass criteria
Order Check Execution Pass criteria Record
01 Dependency restoration Resolve and download all dependencies from the lockfiles, checking private sources, submodules, and cache hits. No unlocked-version drift; dependency resolution completes; key package versions match the local baseline. Lockfile checksum, restoration time, cache key, and failed-retry count.
02 Automated tests Run the project’s unit tests, integration tests, and required simulator tests. The exit code is as expected, failed cases have clear ownership, and test result files can be downloaded. Test target, passed count, failed count, and test-log path.
03 Archive Run Archive with the release configuration and confirm the destination, Scheme, SDK, and build settings. The archive directory is complete; the build and commit numbers are traceable; the warning count is recorded. Archive duration, Xcode version, commit, and archive checksum.
04 Signing check Verify the signing identity, team identifier, provisioning profile, Entitlements, and target bundle identifier. The signing chain matches the project requirements, and sensitive materials do not appear in public logs or artifact directories. Check result, exceptions, owner, and verification-command output.
05 Artifact download Export the expected artifacts to the acceptance location and check file size, checksum, and extraction results. Artifacts download completely, checksums match, and naming and retention follow team standards. Filename, size, checksum, download duration, and storage location.
Baseline A

Clean build

Run after clearing regenerable caches to measure full dependency restoration and compilation time. Record disk space before and after to avoid mistaking insufficient space for a compilation issue.

Baseline B

Cached build

Run again without changing the code to confirm that the cache key works and incorrect artifacts are not reused. Both builds must use the same commit and toolchain version.

Baseline C

Failure sample

Keep one controlled failure in the log format to confirm that CI captures the exit code, key error, test results, and artifact state—not just what is visible in an interactive session.

Long-running operation

Turn one successful build into a sustainable workflow

A cloud Mac can run normally 365 days a year, but long-running tasks still require disk, cache, credential, upgrade-validation, and pre-order-end export procedures. Put these checks in the daily runbook instead of relying on memory.

OPS 01

Disk-space alerts

Monitor source, DerivedData, archives, caches, and log directories separately. Alert thresholds should account for both remaining capacity and growth rate, and recipients must be able to clean up or export data.

Recommended records Total capacity, available capacity, daily growth, and maximum single-archive size.
OPS 02

Cache cleanup rules

Clean caches by project, toolchain version, and last-used time. Keep lockfiles and cache-key records so you can verify that a re-download after cleanup is expected.

Recommended records Cache path, retention period, cleanup command, result, and space released.
OPS 03

Credential rotation

Use least-privilege credentials separately for repositories, artifact sources, and CI, and record expiration dates and owners. After rotation, verify that old credentials are invalid and new ones cover only required resources.

Recommended records Credential purpose, permission scope, expiration date, rotation owner, and verification result.
OPS 04

System-upgrade validation

Before upgrading, validate Xcode, command-line tools, signing, dependencies, and rollback materials on non-critical tasks. VMDebug does not set scheduled downtime; users schedule upgrades around their own workloads.

Recommended records Pre-upgrade version, target version, compatibility result, rollback materials, and execution time.
OPS 05

Task-failure rollback

Keep the last usable task definition, toolchain manifest, and key artifact checksums. If a change fails, stop new tasks first, restore the verified configuration, and retain the failure logs.

Recommended records Trigger condition, pause method, restored version, verification command, and owner.
OPS 06

Export before the order ends

Before the order ends, export and verify code, keys, archives, logs, and required caches. Check checksums after downloading, then remove sensitive content that no longer needs to remain on the device.

Recommended records Export checklist, destination, checksum verification, completion time, and reviewer.
Recommended run cadence

Record the exit code and key logs for every build; check disk growth and caches weekly; rotate credentials according to team security policy; validate compatibility before toolchain changes; and reserve ample time for data export before the order ends.

Review billing and usage boundaries
Ready to start

Onboard your first cloud Mac with the runbook

Choose VMDebug M4 or VMDebug M4 Pro, then select a runtime location from Singapore, Japan (Tokyo), South Korea (Seoul), Hong Kong, and the U.S. West. Only USDT-TRC20 and Visa / Mastercard / Amex (via Stripe) are supported; all orders are billed in USD.