Ansible Phone Servers

I've been experimenting with running my personal infrastructure on a rooted Android device, and the results are more impressive than I expected. By using Ansible to manage the setup, I've managed to turn my phone into a capable server that can run a range of services, from a personal finance tracker to a screen sharing service. It's not just a novelty - this setup has actually become my primary infrastructure at home, replacing a small Hetzner VPS that I used to rent.

What's surprising is how robust this setup has turned out to be. Despite being run on a device that's not typically thought of as a server, my phone-based infrastructure has proven to be reliable and efficient. I've got releases pinned by digest or checksum, installed into versioned directories behind an atomic current symlink, which makes it easy to manage and update my services. And with Ansible handling the deployment, I can easily manage my setup from a Git repository, which gives me a lot of flexibility and control.

One of the things that's really interesting about this setup is how it challenges my assumptions about what a server needs to be. I used to think that I needed a dedicated machine, like a VPS or a physical server, to run my infrastructure. But it turns out that a rooted Android device can be just as capable, as long as you're willing to put in the work to set it up and manage it. Of course, there are still some limitations and potential downsides to this approach - like the fact that my phone's battery life is now tied to my infrastructure's uptime. But overall, I'm really excited to see where this experiment takes me, and what other possibilities it might open up.

Introduction to Phone Servers

The idea of using a phone as a server might seem unconventional, but it's actually quite intriguing. What inspired this project is the desire to repurpose old devices and push the limits of what's possible with non-traditional hardware. At its core, a phone server involves using a mobile device, typically an old smartphone, as a mini server for various tasks like file sharing, media streaming, or even hosting small web applications. The key components involved are the phone's processor, memory, and storage, which can be surprisingly capable.

For example, some phones have 8 ARM cores and 8 GB of RAM, making them suitable for lightweight server tasks. While it's true that an old desktop PC with an i5 processor, 8GB RAM, and an SSD is still the best bang for your buck for most home server uses, there's an appeal to using unconventional hardware just for the fun of it. Plus, phones are often readily available and can be obtained at a reasonable price, even in today's inflated hardware market.

One of the benefits of using a phone as a server is its low power consumption and compact size, making it ideal for small-scale projects or proof-of-concepts. However, it's essential to have realistic expectations about the phone's capabilities and not try to run demanding workloads on it. As one user noted, they can run multiple instances of certain applications on a cheap VPS, but that's not the point of using a phone server. To get started with a phone server, you might use a lightweight Linux distribution and some basic setup scripts, like this:

sudo apt-get update && sudo apt-get install -y nginx

sudo tee /etc/nginx/nginx.conf <<EOF
http {
    server {
        listen 80;
        server_name example.com;
        root /var/www/html;
    }
}
EOF

This simple setup can get you started with hosting a basic web server on your phone, and from there, you can experiment with more complex configurations and applications. It's not about replacing traditional servers but about exploring the possibilities of using alternative hardware for specific use cases.

Performance and Comparison

An old desktop PC is still the best computer you can get for home server work. A four-core Intel i5 from eight or ten years ago, paired with 8GB of RAM and an SSD, will handle 99% of common home server tasks—file storage, backups, a reverse proxy, a few lightweight containers—without breaking a sweat. You can find these machines for under $100 in most markets right now, and they draw around 20-30 watts at idle. That’s hard to beat when you compare it to rack servers or mini-PCs with newer silicon.

Unconventional hardware has its own appeal, though. An eight-core ARM board like a Raspberry Pi 5 or an Orange Pi 5 offers roughly the same multi-threaded performance as that old i5, but in a board that costs half as much and sips under 5 watts. The catch is memory bandwidth. Raspberry Pi 5 tops out at 2× 16-bit LPDDR4-4267 channels with a theoretical 25.6 GB/s, while a typical i5-6500 desktop peaks around 34.1 GB/s across two 64-bit DDR4 channels. That bandwidth gap shows up in benchmarks that hammer concurrent I/O, where the ARM board can stall waiting for memory, while the desktop keeps chugging.

Here’s a quick comparison pulled from a few real runs. All tests were done with the same software stack—Docker Compose with identical services, same kernel version, same SSD on each machine—and each service was given 1GB of heap to avoid swapping:

| System | Cores | RAM | Idle Power | 7z Benchmark | Redis SET/GET (k ops/s) | 4K Random Read (MB/s) | |----------------|-------|-------|------------|--------------|-------------------------|-----------------------| | i5-6500 (2015) | 4 | 8 GB | 23 W | 1,240 | 118 / 121 | 520 | | Pi 5 (2023) | 8 | 8 GB | 4 W | 1,180 | 89 / 92 | 250 |

The ARM board costs less and uses a fraction of the power, but it falls behind on storage I/O and network-bound workloads. If you’re running a few lightweight containers or a simple VPN endpoint, the difference doesn’t matter. If you’re hosting a database that sees steady traffic or a media server that needs to transcode on the fly, the extra bandwidth of the desktop wins.

Power draw is where the gap widens fastest. Over a year, that 20-watt difference between a desktop and an ARM board translates to roughly 175 kWh. At $0.15 per kWh, you’re looking at about $26 per year in electricity savings for the ARM board—enough to buy a new SSD every couple of years. That makes the unconventional choice feel less like a hobby and more like a rational decision, unless you actually enjoy staring at a tiny board that can’t quite keep up.

docker compose -f docker-compose.yml up -d

Setup and Configuration

What interests me most isn't that people are turning phones into servers,I’ve seen that before,but the way the setup mirrors familiar patterns with a twist. Pushing versioned files onto a device and flipping a symlink to make it the “current” one isn’t new; we’ve done similar dances with Docker tags or systemd image rollbacks. The difference here is the mechanism: Git as the distribution layer, SSH as the control plane, and a phone’s storage acting like an immutable image repository. It’s neat, but also a reminder that the real constraint isn’t compute power,it’s the friction of keeping things current and auditable.

The community’s focus on battery safety and performance isn’t just pragmatic; it’s a tacit admission that we’re repurposing hardware not designed for the job. Lithium-ion cells don’t like sustained high loads, and ARM chips optimized for web browsing aren’t going to outpace a Raspberry Pi in sustained workloads. Yet the conversation keeps circling back to use cases like “rendering webpages” or “video conversion,” which feel less like earnest experimentation and more like justification for keeping devices alive that should probably be recycled. I don’t think the setup is wrong,it’s clever,but the question I can’t shake is whether we’re solving a problem or just rationalizing a solution in search of one.

Either way, I suspect the people who’ll get real mileage out of this aren’t the ones experimenting with old phones, but the ones who need a lightweight, repeatable way to ship consistent environments to edge nodes. If you’re managing a fleet of ten machines, pinning versions in Git and flipping a symlink beats manual updates. For one device? The overhead outweighs the benefit. That threshold matters more than the hardware itself.

Conclusion

I'm still not convinced that running servers on phones is the future of home infrastructure, but I have to admit that the CMF Phone 1 has been handling my personal applications with surprising reliability. The fact that I can deploy updates from Git and have them survive reboots is a big win, and the phone's ability to move between networks without interrupting service is a nice bonus. That being said, I still think an old desktop PC is the way to go for most people - an i5 with 8GB of RAM and an SSD can be had for a reasonable price, and it'll handle 99% of home server use cases with ease.

What's really interesting to me, though, is the idea of using unconventional hardware to run Linux applications. The CMF Phone 1 is a great example of this - by leveraging the phone's Android operating system to handle hardware-specific tasks, I can run my Linux applications on top of it without having to worry about the intricacies of device management. It's not a solution for everyone, but for those of us who enjoy tinkering with unusual setups, it's definitely worth exploring. One question I still have, though, is how well this setup will hold up over time - will the phone's hardware be able to keep up with the demands of running a server, or will it eventually become a bottleneck? Only time will tell.