Farmly is the evolution of appium-device-farm — same lineage, distributed architecture, built for the size of farm your CI now actually depends on.
appium-device-farm
Monolithic Appium plugin
One process. One point of failure.
Farmly Hub-Node
Distributed orchestrator + runners
Independent nodes. Isolated failures.
Devices per farm
Hub uptime target
Cleanly separated
On node deploys
Why we moved to Hub-Node.
Production farms ran into the same five walls. Each had a forcing function — and each got a clean architectural answer.
Failures stay local
One node crashes, the others keep serving. The hub routes around the failure — no single process can take the entire farm offline.
Persistent transport
WebSocket replaces HTTP polling: faster round-trips, automatic reconnection, no brittle long-running session glue.
HUB
orchestrator
NODE
runner
WEB
frontend
Three packages, clean boundaries
Hub, Node, and Frontend ship as independent packages — versioned separately, tested in isolation, deployed without coordination.
independent release timelines
Deploy without interrupting tests
Roll out a node update without restarting the hub. Patch the hub without dropping running sessions. Both sides version on their own clock.
row-level locking
A real multi-node database
Row-level locking, true concurrency, write durability. LokiJS and SQLite couldn't safely handle multiple writers — Postgres does, and the farm scales to match.
At-a-glance comparison
Two architectures, same problem space — picked apart row by row.
| Aspect | Plugin · appium-device-farm | Orchestrator · Farmly |
|---|---|---|
| Architecture | Monolithic Appium plugin | Distributed Hub-Node system |
| Installation | appium plugin install device-farm | Hub + Node services + PostgreSQL |
| Communication | HTTP polling | WebSocket (persistent, faster) |
| Codebase | Monorepo (cluttered) | Clean separation (3 packages) |
| Scalability | Supports multiple nodes | Optimized for 10–500+ devices |
| High availability | Single point of failure | Node failures don't affect Hub |
| Database | LokiJS + Prisma/SQLite | PostgreSQL (multi-node concurrency) |
| Deployment updates | Requires Appium restart | Hub & Nodes update independently |
| Fault isolation | Crash affects all devices | Crash affects only that node |
| Use case | Small teams, CI/CD | Production farms, enterprises |
| Observability | Limited (mixed Appium logs) | OpenTelemetry (traces, metrics, logs) |
Which should you use?
Both are alive. Both are supported. The right answer is the one that matches the shape of your operation.
Small team, single host
- Managing fewer than 10 devices
- One developer or a tight squad
- Simple CI/CD pipeline, no HA needs
- You want minimal setup complexity
Production farm, real load
- Managing 10+ devices, often hundreds
- Enterprise or shared platform team
- 99.9% uptime is non-negotiable
- Devices spread across labs and regions
- Scalability and fault tolerance matter
What you get with Farmly
Twelve capabilities — eight you already expect from a device farm, four that only come from going Hub-Node.
Enhanced session management
Streamline test workflows for efficiency — setup and oversight of driver sessions on iOS simulators, tvOS devices, and Android devices, all from one control plane.
Automated device recognition
Hassle-free testing as the system auto-detects connected Android, iOS, and tvOS devices — both simulators and real hardware — before session initiation.
Proactive pool management
During execution, the device pool updates with newly available hardware so tests always run on the freshest resources available.
Parallel testing, port-isolated
Concurrent runs through random-port allocation — boosts efficiency and decreases total testing duration without collisions.
Remote test execution
Built for distributed teams and diverse testing settings. Run on devices that live anywhere your network can reach.
Hands-on manual control
Testers get full device commands for exploratory, debugging, and user-interaction tests — depth and quality without leaving the platform.
Cloud-based testing
Integrates with cloud providers, allowing executions on cloud-hosted devices when on-prem capacity needs to flex.
Advanced reporting insights
An extensive dashboard delivers in-depth analysis of outcomes — informed decisions, strategic planning, no spreadsheet archaeology.
Fault-isolated by design
A crash takes down one node's devices, never the whole farm. The Hub keeps routing tests around the failure.
WebSocket transport
Persistent, faster, auto-reconnecting connections replace HTTP polling — better latency, better error recovery, less noise.
PostgreSQL state
Multi-node concurrency with row-level locking. No more LokiJS / SQLite tug-of-war when nodes scale past one.
OpenTelemetry built in
Traces, metrics, and logs — not a mixed Appium log file. Plug it into Grafana, Tempo, or your stack of choice.
Build the farm your team actually deserves.
Start with the setup guide, plug in your first node, and watch the Hub light up. From single laptop to 500-device lab — same path.