~$1 Million Paid to Developers Who Built Railway Templates

Railway has now paid out almost ~$1 Million to people who build and maintain software on the platform. Roughly ~$730k of that has already been delivered as cash. Two contributors have earned more than $100,000. Six have earned more the $10,000. Thirty have earned more than $1,000.

Total payouts from Railway’s template kickback program

The rest is either sitting in credits or waiting for users to cross the $100 withdrawal minimum. Here's how it works.

Templates on Railway let you package up services into reusable projects. They let you bundle configuration, services, databases and environment setup into something that can be deployed with one click. Some are complex multi-service setups that would take hours to configure manually. Anyone can create one.

At the time of writing, there’s 1800+ live templates on the Template Marketplace. Here are some examples of what you can deploy:

• AI: n8n, LibreChat, Bytebot
• Analytics: PostHog, Metabase, Umami, Plausible
• Bots: Discord, Telegram
• CMS: Wordpress, Strapi, Directus
• Automations: Browserless, Typebot
• Observability: Grafana Stack, Uptime Kuma
• Database browsers: pgadmin, Drizzle Studio gateway
• Video processing/conversion: FFmpeg, Handbrake

When we launched template support in 2023, the idea was simple: if someone has already figured out how to deploy something correctly, that knowledge should be reusable. There's nothing noble about suffering through configuration problems that someone else already solved. Every hour spent debugging why two services aren't communicating, or tracking down a missing environment variable, is an hour not spent on the thing you actually set out to build. Templates eliminate that friction.

Templates worked well. People published them, other people used them, deployments that would have taken an afternoon happened in one click. The mechanical problem was solved.

You can probably guess where this is going: People would publish a template, it would get traction, other developers would start depending on it, and then the original creator would move on.

This is the lifecycle of most community-contributed software. The initial burst of enthusiasm gives way to the reality that maintenance is work, and work without compensation eventually stops happening.

The Template Kickback program was our answer to this.

The structure is simple: when someone runs your template on Railway, they earn a % of whatever Railway makes. Not a one-time payment for publishing. Recurring revenue, for as long as they keep the template running.

This creates the right incentives. Instead of templates being something you publish and forget, they become something that generates income as long as it stays useful. If you publish a template, keep it maintained, and users keep running it, you keep getting paid.
The payout mechanics evolved over time as the program grew. Initially, earnings went into Railway credits. This was convenient for people who were already running workloads on the platform, but limiting for anyone who wanted actual money.

So we added withdrawals through Buy Me a Coffee and GitHub Sponsors, which worked for a while. But as template revenue grew into real numbers, the manual processes didn't scale. Approvals took time, payout options were limited, and the whole thing felt held together with tape.
We eventually integrated Stripe Connect, which makes it possible to link a bank account or debit card, and withdrawals happen directly. The Earnings & Withdrawals page in your dashboard tracks everything: what you've earned, and what's available to withdraw.

Today, template creators can earn up to 25% of what Railway makes from their template deployments. No limits, no minimum threshold. If someone deploys your template and keeps it running, you earn a cut of their usage for as long as it stays up.
That 25% is split into two parts:

• 15% comes from template usage directly. Someone deploys your template, runs workloads on it, you get paid.
• 10% comes from answering questions about your template. When users need help configuring, extending, or debugging something, you earn additional revenue for providing that support (More on that later).

We believe that great templates need ongoing care, and the people providing that care should be compensated for it. The 15/10 structure rewards both building and maintaining.

Central Station is Railway's support and community platform. It aggregates user context from the Railway platform and allows users to create threads that are visible to the support team. We built it because existing support tools did not fit our workflow. We tried the off-the-shelf options and none of them handled the complexity that comes with a platform where users can deploy anything: apps, services, cron jobs, queues, databases, whatever they need.

As the platform grew, user behavior shifted. People were no longer just asking for help. They started sharing ideas, reporting bugs, and actively trying to shape Railway's direction.

Central Station evolved to accommodate this. It became an async forum where the community could contribute answers, surface feature requests, and participate in the product development process.

station.railway.com

This evolution continued with templates. We recently shipped the ability to open threads against specific templates, so users can ask questions about a template and get help from the creator or anyone else in the community. For template creators, this means a direct line to the people using your work. For users, it means you're not stuck when something doesn't behave as expected.

But this raised a question: how do you sustain contribution at scale? People have limited time, and helping strangers debug their deployments is real work.

Bounties are our most direct answer. When a problem requires real investigation, we attach a dollar amount to it. Anyone can pick it up and solve it. Once the solution is verified, the contributor receives the payout as Railway credits or cash.

railway.com/bounties

Bounties cover a few categories:

• Debugging questions where someone is stuck and needs a second pair of eyes.
• Content requests where we want users to share what they've built on Railway and how they built it.
• Requests for new templates. For example, here’s a user requesting a template and having it ready in a day.

The mechanism is simple: harder problems get money attached, and the people who solve them get paid. Since we introduced bounties seven months ago, we've paid out almost $10,000 to community members. That number will keep growing.

We didn't set out to fix open-source sustainability. But it's hard not to notice that the system we built addresses some of the same problems.

The standard model for community contribution has been reputation points. Stack Overflow built a billion-dollar company this way. Contributors got points, badges, and social standing. The platform got free labor. For a while, it worked. Being a top Stack Overflow contributor meant something on a resume. The social proof had real career value, which made the free labor feel less like free labor.

Then LLMs showed up and made commodity answers essentially free. The questions that still require human expertise are the messy ones: context-specific debugging, architecture decisions, problems where you don't know what you don't know. Nobody is going to spend an hour digging through someone's Dockerfile for fake internet points when ChatGPT exists.

The other approach has been donation-based: GitHub Sponsors, Open Collective, Patreon. These help some maintainers, but they don't scale. Donations require people to feel generous. Markets just require people to want things.

What we built is closer to a market. You create something useful, people use it, you get paid. You help someone, that help has a dollar value attached. The compensation is automatic, not dependent on goodwill.

This isn't a grand solution to open-source sustainability. But it's a model that works for a certain class of contributions, and it's already moving real money.

The goal is a marketplace for software and expertise where contribution is compensated by default. When you write a template, you get paid when people use it. When you answer questions, you get paid for your time. When you help someone debug a deployment, that has a dollar value.

The infrastructure is in place. The payouts are real. The only question is how big this can get.

Come build something and get paid for it. 🚄