Getting Tiny Little Fly to Actually Work for Your Workflow
I picked up Tiny Little Fly about two years ago when my team needed a lightweight automation tool that wouldn't require a dedicated dev to maintain. It promised quick scripting without the overhead of something like an Airflow pipeline or a full Python project. It mostly delivered, though not without some quirks worth knowing about before you invest time in it. The installation is straightforward if you're on Linux or macOS. You can grab it from the GitHub releases page—the official repo has binaries for x86_64 and arm64. I'd skip the Docker option unless you're already running a container setup; the binary is faster and more predictable for daily use. Just download the latest release, make it executable with chmod +x, and drop it somewhere in your PATH. That's it. Takes about three minutes on a decent connection.
Setting Up Your First Tiny Little Fly Script
Scripts in Tiny Little Fly are just YAML files with a specific schema. The first time I wrote one, I spent twenty minutes debugging because I forgot that key names are case-sensitive. The docs don't mention that prominently, but once I realized it, it saved me a lot of frustration. A basic script looks like this: Example structure: name: backup_logs
schedule: "0 2 * * *"
steps:
- run: tar -czf /backups/logs-$TIMESTAMP.tar.gz /var/log/myapp/
- notify: slack#ops-channels
message: "Backup completed"
The built-in scheduler runs cron expressions natively, so you don't need to wire up a separate cron job or crontab entry. That alone cut my maintenance overhead significantly. Before Tiny Little Fly, I was juggling three different scheduling systems across two servers. Now everything lives in one place. One thing beginners usually miss: Tiny Little Fly doesn't pipe command output between steps by default. Each step is isolated. If you need to capture a variable from one step and use it in the next, you have to explicitly set and reference variables. I wasted a day on a script where the second step kept failing because it was looking for a variable that was never actually exported from step one. The fix was adding $OUTPUT to the first step and piping it into the second. Not obvious from the README, but the troubleshooting guide covers it. Here's the part that won't make it into any marketing material: Tiny Little Fly struggles with long-running processes. If a single step takes more than ten minutes, the execution context can get flaky. I ran into this when someone tried to use it for a database migration that routinely took forty-five minutes. The script would hang mid-execution without a clear error message. The workaround was splitting the migration into batched chunks of under five minutes each, wrapped in a loop. It wasn't elegant, but it worked reliably after that.
Get the Full Details
Another counter-intuitive detail is how Tiny Little Fly handles failures. By default, it stops on the first error and reports it. That sounds fine until you realize it means a single failed notification step can prevent the actual task from completing if the order is wrong. I rewrote one of my scripts entirely because the Slack notification step was placed before the backup step, and when Slack was temporarily unreachable, the whole thing aborted before backing anything up. Put your critical operations first. Notifications last.
Common Pitfalls and When to Walk Away
Tiny Little Fly works well for small-to-medium orchestration tasks—daily backups, cleanup jobs, simple data syncs, periodic API calls. It's not designed for distributed workloads, dependency-heavy pipelines, or anything requiring complex branching logic. If your use case involves more than five or six sequential steps with conditional logic, you're better off with something like Prefect, Dagster, or even a well-structured shell script with proper error handling. The biggest limitation I hit personally was around concurrent executions. The tool runs sequentially by default, and while there's a concurrency flag, it doesn't handle race conditions well. Two instances writing to the same file at the same time will corrupt it. I learned this the hard way when two scheduled jobs overlapped during a daylight savings time shift and wiped a shared config file. I ended up adding file locks using flock as a workaround, which added about five extra lines per step but kept things stable afterward. There's also no built-in secret management. You can store API keys in your YAML files, but that means they end up in version control if you're not careful. I started using environment variables for sensitive data and referencing them with ${ENV_VAR} syntax, which keeps secrets out of the script files entirely. Still, it's not ideal. If your team needs serious secret handling, look at HashiCorp Vault integration scripts or move to a platform that ships with it.
For most people doing routine automation on a handful of servers, Tiny Little Fly is a solid choice. It's fast to set up, the YAML format is readable, and the scheduler removes the need for external cron management. But don't force it into a role it wasn't built for, and pay attention to the error handling order in your scripts. Those two things will save you more trouble than anything else.
