How to Self-Host a Modded Minecraft Server with Automated Backups (Fabric, Paper) 2024
Modded Minecraft is a beautiful disaster. You start with “just a few QoL mods” and end up with 200 of them, a dedicated GPU for shaders, and a deep emotional attachment to a digital potato farm. Public servers offer convenience, but they tend to come with restrictive mod lists, laggy TPS when someone builds a 10,000-cow farm, and pricing that makes you wonder if they’re cooling the racks with liquid gold. Renting a managed host can work, but you’re surrendering control—and sometimes the ability to add that one mod that turns creepers into top-hat-wearing gentlemen.
Self-hosting a modded server puts you in charge. You pick the modpack, the world seed, the backup schedule, and the exact moment you “accidentally” delete your friend’s dirt shack. It also forces you to learn a few sysadmin skills that will make you feel like a wizard every time you SSH into a headless Linux box. Combined with automated backups—so a corrupted world file doesn’t send you into a three-day grieving period—self-hosting is the only way to play if you value your sanity and your wallet.
The catch? Most guides either assume you’re running vanilla Minecraft in 2015 or hand-wave the tricky parts: mod loaders, Java versions, and backup strategies that don’t involve manually copying folders at 3 AM. This guide is different. I’ll walk you through building a modded Fabric or Paper server from scratch, setting up bulletproof automated backups, and doing it all without treating yourself as a volunteer IT support ticket for your entire friend group. We’ll cover 2024’s quirks—Java 21 requirements for Minecraft 1.20.5+, the death of Forge as the default mod loader, and how to sleep soundly knowing your Netherite beacon base exists in at least three separate geographic locations.
The Holy War: Fabric vs. Paper for Modded Servers
You’ll notice I didn’t mention Forge. There’s a reason. Forge still works, but in 2024, the modding community has largely migrated to Fabric for lightweight, modular mods and to Quilt (a Fabric fork with more governance). Forge isn’t dead—it’s just the grumpy elder god that demands exact version matches and can turn a server startup into dependency-hell. Paper, on the other hand, isn’t a mod loader in the Forge/Fabric sense. It’s a high-performance fork of the vanilla server that supports plugins (think Bukkit/Spigot ecosystem). Can you run Fabric mods on Paper? No. But you can run a server that is mostly vanilla with performance patches and plugins for things like land claiming, economy, and anti-griefing. Many “modded” experiences that rely on datapacks and plugins rather than jar-modifying mods thrive on Paper. So the choice boils down to:
- Fabric: You want actual client-side mods on the server that add new blocks, mechanics, dimensions, and weird items. Mods like Create, Origins, or anything that fundamentally changes gameplay. You’ll need your players to also install those mods on their clients.
- Paper: You want a highly optimized vanilla-feel server augmented by server-side plugins. Good for SMPs, minigames, and servers where you don’t want to force everyone to install a custom modpack. Plugins handle backups, permission nodes, and performance tweaks.
I’ll cover both, so you can pick your poison.
Hardware You’ll Actually Need (and the Cloud Option)
A modded server is a RAM-glutton. If you’re running a heavy pack with 150+ mods and five players, expect to allocate at least 6GB of heap. An old laptop with 8GB total RAM might scrape by for a light Fabric pack, but you’ll feel the pain when generating chunks. Ideally, you want a dedicated machine with a recent CPU (single-core speed is king for Minecraft’s main thread) and an SSD. A used Dell Optiplex with an i5-8500 and 16GB RAM off eBay will happily run a medium modpack and act as a file server for backups. Linux is non-negotiable for stability; Ubuntu Server 22.04 LTS is boring but works.
If you don’t want a physical box humming in your closet, renting a VPS is perfectly valid. Just avoid “Minecraft host” companies that oversell ancient Xeons. General-purpose cloud providers give you better performance per dollar. DigitalOcean droplets are straightforward, with SSDs and predictable pricing; their $24/month 4vCPU/8GB droplet handles a modded server gracefully. For even more RAM per euro, Hetzner cloud servers offer excellent bare-metal-adjacent performance, with their CX41 (8GB, 4 vCPU) often coming in under €12/month. Either will run Fabric or Paper beautifully and give you a public IP so friends can connect without port-forwarding nightmares.
Regardless of hardware, install Java 21. Minecraft 1.20.5 and later require Java 21 for the server (clients need 21 as well). It’s a hard requirement, not a suggestion. Use sudo apt install openjdk-21-jre-headless and verify with java -version.
Spinning Up the Server: Fabric First
Grab the official Fabric installer from fabricmc.net. Don’t download random server JARs from YouTube descriptions—you’re better than that. The installer is a single command-line Java app that generates the server JAR and library folders. Assuming you’ve created a dedicated minecraft user and directory /opt/minecraft, do:
curl -OJ https://maven.fabricmc.net/net/fabricmc/fabric-installer/1.0.0/fabric-installer-1.0.0.jar
java -jar fabric-installer-1.0.0.jar server -mcversion 1.20.6 -downloadMinecraft
(Check the latest version; 1.0.0 is just a placeholder—get the current release.)
This drops fabric-server-launch.jar and a libraries folder. Start the server once to generate eula.txt, set eula=true, then launch it inside a screen or tmux session so it survives logouts:
screen -S minecraft
java -Xmx6G -Xms4G -jar fabric-server-launch.jar nogui
Detach with Ctrl+A, D. Before you invite anyone, copy your mods into the mods/ folder. Remember: every mod that adds content must be present on both server and client. Client-only mods like OptiFine alternatives (Sodium, Iris) stay out of the server mods folder. Reboot the server and test that it loads without errors. Check logs/latest.log for missing dependency warnings—Fabric will yell at you but won’t always crash instantly.
Spinning Up the Server: Paper and Plugins
Download the Paper JAR directly from papermc.io. Choose the Minecraft version you want; 1.20.6 builds are stable. Place the JAR in your server folder as paper.jar. First launch is identical: accept the EULA, then tweak server.properties and Paper’s own config files (config/paper-world-defaults.yml and paper-global.yml). Paper applies performance patches like per-player mob spawn limits, async chunk loading, and entity-activation ranges out of the box, but you can fine-tune them.
Plugins go into the plugins/ folder. For automated backups, I recommend a plugin like DriveBackupV2, which can upload to Google Drive, OneDrive, or SFTP, but we’ll discuss a more universal method later that works for both Fabric and Paper without relying on a plugin’s up-time. For now, install at least LuckPerms (permissions) and CoreProtect (block logging). Start the server with:
java -Xmx8G -Xms4G -jar paper.jar nogui
Paper uses Aikar’s flags by default if you use their startup script, but I prefer to keep it simple and tune garbage collection manually only if needed. Most Paper servers are happy with a 8–10GB heap and play nice with the ZGC garbage collector if you’re on Java 21: add -XX:+UseZGC. That’s an advanced tweak—don’t cargo-cult it without testing.
Both Fabric and Paper setups should now respond on localhost:25565. Configure your firewall: for a home server, forward port 25565/TCP in your router to the server’s local IP. For a VPS, open the port in the cloud firewall (DigitalOcean’s, Hetzner’s) and optionally use ufw on Ubuntu.
Automating Backups Without Losing Your Mind
Manual backups are a lie. You’ll do one after the initial setup, feel proud, then never do it again until the day after your world corrupts. Automate it. For both Fabric and Paper, the gold standard is a shell script that runs via cron, safely stops world saving, copies the world folder, and restarts saving—all while the server stays up. Minecraft servers support the save-off and save-on commands, which disable and re-enable writing to disk. Combined with save-all, you can take a consistent snapshot without a full restart.
Create a script /opt/minecraft/backup.sh:
#!/bin/bash
SERVER_DIR="/opt/minecraft"
SCREEN_NAME="minecraft"
BACKUP_DIR="/mnt/backups/minecraft"
DATE=$(date +%F_%H-%M)
# Force a full save, then disable saving while we copy
screen -S $SCREEN_NAME -p 0 -X stuff "save-all\n"
sleep 5
screen -S $SCREEN_NAME -p 0 -X stuff "save-off\n"
sleep 10
# Copy the world directory (adjust world name if not "world")
cp -r $SERVER_DIR/world $BACKUP_DIR/world_$DATE
# Re-enable saving
screen -S $SCREEN_NAME -p 0 -X stuff "save-on\n"
Make it executable (chmod +x backup.sh). Schedule it with cron to run every 4 hours: 0 */4 * * * /opt/minecraft/backup.sh. This will accumulate full copies, so you’ll need a clean-up strategy. Add a line to delete backups older than 7 days:
find $BACKUP_DIR -type d -name "world_*" -mtime +7 -exec rm -rf {} \;
Place that in the script after the copy, or in a separate cron job. If you’re running a Paper server, this method still works—no plugin required. And it’s mod loader agnostic because it uses the server console. Perfection.
Off-Site Backups: Because Your House Might Burn Down
Local backups protect you from corrupt chunks and accidental /kill @e commands. They do not protect you from a failing SSD, a lightning strike, or your cat knocking the server off the shelf. You need an off-site copy. The easiest path is rclone paired with cheap object storage. Backblaze B2 gives you 10GB free and then $0.005/GB/month, which means storing a few gigabytes of compressed world backups costs literal pennies.
Install rclone (sudo apt install rclone), then configure it with rclone config to add a B2 remote (you’ll need a Backblaze account and application key). Afterwards, modify your backup script to compress the world directory and upload it. Append these lines:
# Compress the backup
tar -czf $BACKUP_DIR/world_$DATE.tar.gz -C $BACKUP_DIR world_$DATE
# Remove uncompressed folder (optional)
rm -rf $BACKUP_DIR/world_$DATE
# Upload to B2 bucket (replace 'mc-backups' with your bucket)
rclone copy $BACKUP_DIR/world_$DATE.tar.gz b2:mc-backups/latest/
# Keep only last 3 offsite backups to manage storage
rclone delete --min-age 90d b2:mc-backups/latest/
Schedule this right after the local backup, or bundle it in the same script. Now your world exists in at least two data centers. If you’re feeling extra paranoid, add a second rclone remote for Google Drive or a friend’s SFTP server. Your friends will mock you until the day they accidentally delete the Dragon Egg and you restore the world in minutes.
Performance Tweaks and Cron Jobs for Maintenance
Modded servers eat CPU cycles like potato chips. Fabric’s open ecosystem means some mods aren’t optimized; Paper is generally smoother, but both benefit from a few universal tweaks. In server.properties, lower view-distance to 8–10 and simulation-distance to 6–8. These drastically reduce chunk loading without hurting gameplay. Pre-generate your world with a mod like Chunky (Fabric) or a plugin like ChunkyBorder (Paper) so that exploration doesn’t hammer the server later. Run the generation overnight.
Set up additional cron jobs for housekeeping. Delete old logs:
find /opt/minecraft/logs -name "*.log.gz" -mtime +14 -delete
Restart the server daily to free leaked memory—modded servers leak, it’s a fact of life. Add a restart script that sends a 5-minute warning and shuts down gracefully, then starts again via a systemd timer or cron. For a Fabric server, you might use:
screen -S minecraft -p 0 -X stuff "say Server restarting in 5 minutes!\n"
sleep 300
screen -S minecraft -p 0 -X stuff "stop\n"
sleep 30
# systemd will restart the service if you set it up with a unit file
If you’re using a VPS, consider enabling swap (a small 2GB swap file) to handle memory spikes without OOM-killing the JVM. It’s not ideal, but better than the server vanishing mid-raid.
Conclusion: Your World, Your Rules
Self-hosting a modded Minecraft server in 2024 isn’t the arcane ritual it was a decade ago. Fabric and Paper have matured, Java 21 unifies the runtime, and tools like rclone make off-site backups a Copy-Paste affair. You no longer need to sacrifice performance or control to a $30/month hosting reseller that “accidentally” wipes your world during a panel migration. By owning the iron—whether it’s a quiet mini-PC under your desk or a Hetzner instance in Nuremberg—you gain the freedom to tinker, the power to roll back gargantuan mistakes, and the smug satisfaction of telling your friends, “Yeah, I run it myself.”
Start with a fresh Ubuntu install, pick Fabric for deep mods or Paper for a buttery-smooth plugin experience, wrap the whole thing in cron-driven backups, and sleep soundly. Your Netherite throne awaits.