Code to Customers

Aequo Labs builds the missing infrastructure between writing software and getting it into the hands of paying customers. Indie Legs is the licensing-and-distribution backbone of that stack.

Back to Indie Legs -- Features -- Use Cases -- Compare to Alternatives


The Problem

It started with a simple question: how do you sell a licensed desktop application?

The founder had built a product and needed to sell it. Not a SaaS, not an API — an actual downloadable, installable piece of software with license keys and per-machine activation. The kind of thing that should be straightforward.

It wasn't.

The options were bleak. The major app stores take 30% and dictate your terms. Shopify and its cousins charge monthly fees that eat into margins before you've sold a single unit. The "roll your own" path means stitching together a payment processor, a license server, an installer pipeline, a download portal, and a customer-facing storefront — each one a project unto itself.

For a developer selling one or two niche products, the math doesn't work. You'd spend more on the tools to sell your lonely product than you'd ever make back. The barrier to entry isn't the code — it's everything after the code.

The Mission

Level the playing field for indie developers.

That's it. That's the whole mission.

The further along the founder got building licensing infrastructure for his own product, the more last-mile gaps he found. License generation, sure — but also activation management, installer building, storefront hosting, payment processing, download distribution, update delivery. Each gap was another reason an indie developer might give up and either not ship at all or hand 30% to a gatekeeper.

Aequo Labs exists to fill those gaps. Not with a platform you rent, but with self-hosted tools you own and control. Your server, your data, your margins.


Infrastructure That Expires Sucks

Here's the thing about most license servers: they're SaaS products that charge you per-seat, per-month, per-transaction. Your entire licensing infrastructure depends on someone else's server staying up and their pricing staying reasonable. If they go under, raise prices, or sunset the product, your licensing breaks. Your customers can't activate. Your business stops.

That's not infrastructure. That's a dependency.

Indie Legs was built to be the opposite. You buy it, you deploy it on your server, and it works. Forever. There's no cloud service to depend on, no API quota to hit, no monthly invoice that grows with your success.


Every Decision Is a Customer Advantage

Perpetual License

Indie Legs licenses don't expire. The license you buy today will still validate licenses for your customers in 10 years, on a server you control. We include 2 years of updates because we want you to have a reason to renew -- not because we need a lever to force it.

If Aequo Labs disappeared tomorrow, your Indie Legs installation would keep running. Your customers would keep activating. Your business wouldn't skip a beat. That's the whole point.

Generous Trial

The trial isn't a crippled demo. It's the full product for 90 days with all features enabled. We'd rather you kick the tires for real and decide it's not for you than have you buy something that doesn't fit. The 14-day grace period after expiration gives you breathing room if the trial slips through the cracks.

Self-Hosted by Design

Your licensing data, customer information, and product binaries live on your server. Not ours, not a cloud provider's, not a CDN's. When a customer activates a license, that validation happens on your infrastructure. When they download an update, it comes from your server.

This isn't a philosophical stance -- it's practical. You can't get held hostage by infrastructure you own.

API-First

Every feature in Indie Legs is accessible through the REST API with full OpenAPI 3.1 documentation. The admin UI and storefront are built on the same API you'd use. This means you can automate anything, integrate with anything, and build workflows we haven't imagined.

We didn't build a UI and then bolt on an API. We built the API and then built the UI on top of it.


The Business Model

We sell software licenses. Same as you do, if you're using Indie Legs.

You pay once for a perpetual license. Your 2-year update window gives you access to every release during that period. After 2 years, you can renew the update window or keep running what you have. No forced upgrades, no version lockout.

We make money when you decide our updates are worth paying for. That's alignment of incentives -- we have to keep shipping value, and you only pay when we do.


Architecture Notes

graph TD
    A[Client Application] -->|License Check| B[Indie Legs Server]
    B -->|Validate| C[License Store]
    B -->|Generate| D[Installer Builder]
    D -->|MSI / DEB / RPM / APK| E[Download Server]
    F[Indie Arms Storefront] -->|Purchase & Provision| B
    G[Admin UI] -->|Manage Products & Licenses| B
    H[Stripe / Shopify Webhooks] -->|Payment Events| B

Indie Legs is a single native binary with an embedded SQLite database. No external dependencies beyond a reverse proxy for TLS. Deploy it on a $5/month VPS or a rack-mounted server -- it doesn't care.

The four-server architecture (admin API on port 9190, webhook receiver on 9191, public API on 9192, storefront API on 9193) enables proper firewall isolation between admin, public, and payment-processing traffic.

The installer builder uses cross-compilation toolchains to produce native packages for every major Linux distribution and Windows. Upload a zip, get back MSI, DEB, RPM, and APK installers with proper metadata, service files, and dependency declarations.


The Stack Indie Legs Replaces

One binary in place of the usual vendor pile:

  • Licensing + activation server
  • .deb / .apk / .rpm package repos
  • Order fulfillment + EDI in/out
  • Physical product fulfillment (shipping addresses, carrier tracking, delivery status)
  • Amazon Selling Partner integration (catalog sync, FBA inventory, order ingest, license delivery)
  • Email campaigns + engagement analytics
  • Product analytics (downloads, update checks, validation events)
  • DR backups of license + order data
  • Backend datasource for the public storefront

See Compare to Alternatives for the side-by-side against Gumroad, Paddle, hosted license servers, and roll-your-own.


Compliance Built In

Self-hosted doesn't have to mean rolling your own compliance plumbing:

  • CAN-SPAM -- HMAC-signed unsubscribe links + granular opt-out by campaign type (all, marketing, new-release, survey).
  • Data retention -- Configurable lifecycle across analytics, download logs, update checks, webhook events, and campaign records. Supports GDPR storage-limitation.
  • Change audit log -- Catalog and pricing changes recorded with admin-user attribution.
  • PCI scope reduction -- Stripe handles card data; nothing sensitive lands on your server.

Content for this section has not been authored yet.

Who Uses Indie Legs?

Indie Legs is built for software vendors who want to own their licensing infrastructure end-to-end. If you're tired of paying per-seat fees to a SaaS license server, or you can't find a hosted option that respects your customer relationships, this is your tool.

Back to Indie Legs -- Features


The Solo Developer Selling a Desktop App

You built something useful. People will pay for it. You don't want 30% of every sale going to an app store, and you don't want to glue together Stripe webhooks, license generation, and a download portal yourself.

Indie Legs gives you the licensing backend in one binary. Pair it with Indie Arms for the storefront, point Stripe at the webhook URL, and you have a complete sales channel. The whole thing runs on a $5/month VPS.

You'll use:

  • License generation and validation
  • Stripe Checkout webhook integration
  • Automatic license delivery emails
  • Multi-platform installer generation

The Small ISV Replacing FastSpring or Paddle

You've outgrown the convenience of a managed reseller. You're paying transaction fees that scale with your revenue, you don't own your customer list, and your storefront looks like everyone else's. You want to keep your business model the same -- you just want to own the infrastructure.

Indie Legs replaces the licensing and distribution layer. Your existing Stripe account handles payments. Your domain hosts the storefront. Your customers think they're buying directly from you because they are.

You'll use:

  • Stripe and Shopify webhook integration
  • Customer database with order history
  • Email campaigns to your existing customer base
  • Hosted package repositories so customers can apt install your product
  • Analytics on which versions are in the field

The B2B Software Company With Procurement Customers

Your enterprise customers want EDI integration, purchase order processing, and proper invoicing. They want to receive your invoices the same way they receive everyone else's: as 810 transactions through their EDI provider. Building this infrastructure yourself is a multi-quarter project.

Indie Legs Professional includes built-in EDI support for X12 and EDIFACT, partner management, and AS2 transport. Onboard a new EDI partner through the admin console, exchange test messages, and switch to production -- without writing a line of EDI parsing code.

You'll use:

  • EDI partner management with up to 5 partners (Professional) or unlimited (Enterprise)
  • AS2 transport with X.509 certificate management
  • Automated 850 / 855 / 856 / 810 processing
  • Audit logging for compliance teams
  • Custom retention policies

The Hardware + Software Company Selling Bundles

You sell a physical device that comes with software. You need stock tracking, fulfillment workflow, and shipping label generation -- and the software side needs license keys delivered with the order.

Indie Legs Professional supports physical and hybrid product types. Stock decrements atomically when orders are placed, fulfillment orders track shipping status, and the same checkout that ships the device generates the software license.

You'll use:

  • Physical and hybrid product types
  • Stock tracking with atomic decrements
  • Fulfillment order workflow (pending -- processing -- shipped -- delivered)
  • Tracking number management
  • License delivery on physical product activation

The Open Source Project With a Commercial Edition

You have a free open source product and a commercial edition with extra features. You want to give the OSS project away and license the commercial bits without forcing OSS users to deal with license keys.

Configure your product with feature flags. The OSS edition checks for an absent license and runs in basic mode. The commercial edition reads license features and unlocks premium functionality. Same binary, different behavior based on what's licensed.

You'll use:

  • Feature flags (boolean / numeric / string)
  • allow_unlicensed_download for the OSS distribution
  • Trial license deduplication to prevent abuse
  • GitHub release auto-import for OSS releases

The Internal Tools Team

You're not selling anything. You're distributing internal tools to other teams in your organization, and you want a proper distribution mechanism instead of email attachments and Confluence pages with broken download links.

Indie Legs gives you internal package repositories, automatic updates, and version analytics for the tools your engineers and analysts depend on. License keys become entitlement tokens identifying which team has access to which tool.

You'll use:

  • Hosted APT, RPM, APK repositories
  • Update analytics to see which versions are in the field
  • Feature flags to gate experimental features by team
  • Audit logging for compliance

The Consultant Building Custom Software for Clients

You build bespoke software for clients and need a per-client licensing story. Each client gets their own license, their own download portal, and their own version history. You don't want to maintain separate distribution infrastructure for each client.

Indie Legs handles this with one server, one binary, and per-customer license isolation. Each client sees their own products in the storefront and their own download history.

You'll use:

  • Customer database with per-customer licenses
  • Storefront API to drive a customer-facing portal
  • Branded email delivery
  • Audit logging for client deliverables

Where Indie Legs Doesn't Fit

Honest about the limits:

  • You want a SaaS license server with no infrastructure to run. Indie Legs is self-hosted. If you want to outsource everything, use a managed provider.
  • You're selling a high-volume consumer mobile app. App stores are the right channel for that. Indie Legs is built for desktop, server, and embedded software.
  • You need a built-in payment processor. Indie Legs integrates with Stripe and Shopify but doesn't process payments itself. You bring your own payment provider.
  • You want a marketing site and CMS. Indie Legs is a licensing backend. For storefront and marketing, pair it with Indie Arms.

Compare to Alternatives -- Back to Indie Legs

Content for this section has not been authored yet.

Indie Legs vs Alternatives

Honest comparisons against the most common alternatives. We'll tell you when something else is the right fit.

Back to Indie Legs -- Features


At a Glance

Indie Legs Gumroad / Lemon Squeezy FastSpring / Paddle Roll Your Own Hosted License Servers
Hosting Self-hosted SaaS SaaS Self-hosted SaaS
Customer ownership You Shared Shared You Mixed
Transaction fees None 5-10% per sale 5-9% per sale None None
Per-seat license fees None N/A N/A None $1-5 per seat / month
Setup time 1-2 days Hours Hours Months Days
Custom domain Yes Limited Yes Yes Limited
Stripe direct Yes No (they're MoR) No (they're MoR) Yes Varies
Source code access Enterprise No No Yours No
EDI built in Pro / Ent No No Build it No
Operating cost at scale Server cost only Scales with revenue Scales with revenue Server + dev time Scales with seats

vs Gumroad / Lemon Squeezy

Both are Merchant of Record (MoR) platforms. They handle payment processing, sales tax, and refunds in exchange for taking a percentage of each sale.

They're better when:

  • You want zero infrastructure to run.
  • You're selling occasionally, not continuously.
  • Sales tax compliance across jurisdictions is genuinely scary to you.
  • You're under $10K/month in revenue and the percentage cut is acceptable.

Indie Legs is better when:

  • You're doing meaningful revenue and the percentage stops feeling small.
  • You want to own your customer list, your refund policy, and your storefront branding.
  • You need real licensing -- per-machine activation, feature flags, version tracking, package repositories.
  • You want a customer database under your control for direct outreach.
  • You're selling B2B and your customers expect direct invoicing.

The math: A 5% MoR fee on $50K/year is $2,500/year. An Indie Legs Standard license costs less and runs forever. The break-even is fast and gets faster as you grow.


vs FastSpring / Paddle / Cleverbridge

Same Merchant of Record model as Gumroad / Lemon Squeezy, but aimed at established software businesses. Better fraud handling, better support, more enterprise features. Same fundamental tradeoff: you trade percentage of revenue for outsourcing infrastructure and tax compliance.

They're better when:

  • You're an established software business that doesn't want to think about VAT, sales tax, or payment fraud at all.
  • Your customer base is global and you don't have the patience to handle international tax compliance yourself.
  • You need a fully managed customer service layer for billing disputes.

Indie Legs is better when:

  • You're already paying significant percentages and the math has stopped working.
  • You have your own support team and don't need a managed billing dispute layer.
  • You want your domain on the invoices, your customer relationship, your data.
  • You need licensing features they don't provide -- specifically per-machine activation, package repositories, and EDI.
  • You're selling to enterprise customers who expect to pay you directly, not a third-party reseller.

The migration path: Many Indie Legs customers ran on FastSpring or Paddle for years and migrated when their percentage fees hit five figures per month. Indie Legs handles the licensing and distribution; you keep your existing payment processor relationship if you want to.


vs App Stores (Microsoft Store, Mac App Store, Steam)

App stores take 15-30% per sale, dictate your customer relationship, control your update cycle, and can deplatform you with little notice.

They're better when:

  • Your product depends on app store discovery for customer acquisition.
  • Your customers genuinely prefer to manage subscriptions through their device account.
  • You're selling consumer software where the trust signal of "in the app store" matters more than the cut.

Indie Legs is better when:

  • You're selling to professionals, businesses, or developers who don't shop in app stores.
  • Your customer acquisition happens through your website, content marketing, or word of mouth.
  • The 15-30% cut is unacceptable.
  • You need flexibility around licensing, pricing, and distribution that app stores don't permit.

Important nuance: Indie Legs and an app store presence are not mutually exclusive. Many customers maintain a Mac App Store version for one customer segment and an Indie Legs direct distribution for another.


vs Building It Yourself

You can absolutely build a license server, an installer pipeline, a download portal, and a Stripe webhook handler. People do.

Build it yourself when:

  • Your licensing requirements are so unusual that no off-the-shelf product fits.
  • You enjoy building infrastructure and have the engineering capacity to maintain it.
  • You're a large enough company that an in-house build pays back over time.

Indie Legs is better when:

  • You'd rather spend engineering time on your actual product.
  • The maintenance burden of a custom solution would compound over years.
  • You want a tested code path for things like cross-platform installers, package repository signing, EDI handshakes, and webhook signature verification.

The honest math: A custom license server is 3-6 months of senior engineering time to build, plus ongoing maintenance. At fully loaded engineering rates, that's tens of thousands of dollars before you ship feature one. Indie Legs costs less than a week of that engineering time.

The features you don't build yourself are the ones you don't have to maintain.


vs Hosted License Servers (Keygen, Cryptolens, LicenseSpring)

These are SaaS license servers with per-seat or per-license pricing. You give them your customer data, they handle license validation and activation.

They're better when:

  • You want a SaaS solution and don't want to run any infrastructure.
  • Your seat count is low enough that per-seat fees are negligible.

Indie Legs is better when:

  • Your customer count is large enough that per-seat fees compound into real money.
  • You don't want your customer data in a third party's database.
  • You need integrated distribution -- not just license validation, but installer generation, package repositories, version analytics, and update delivery.
  • You need EDI, webhook integration, or other features beyond pure license validation.
  • You want one product instead of stitching together a license server, an installer pipeline, a CDN, and a customer portal.

The integration argument: Most hosted license servers do exactly one thing well -- license validation. Indie Legs is a complete distribution stack. If you choose a hosted license server, you're still going to need solutions for installer generation, version distribution, and customer-facing storefront. With Indie Legs, those are included.


vs Multi-Channel / Amazon Tools (Sellercloud, Linnworks, ChannelAdvisor, Skubana)

If you sell on Amazon as well as direct, you usually need a second tool to bridge them: order ingest, catalog sync, FBA inventory, shipment-status push-back. That's a separate monthly bill on top of the licensing server.

Indie Legs covers the Amazon Selling Partner integration directly:

  • Catalog sync to Amazon -- push your product listings to the Amazon catalog via SP-API.
  • FBA inventory -- track Fulfilled-by-Amazon inventory levels alongside your direct sales.
  • Order ingest -- Amazon orders flow into the same orders table as Stripe / direct sales.
  • License delivery -- digital licenses get issued to Amazon-channel customers automatically on order.
  • Shipment status push-back -- mark physical orders as shipped in Indie Legs and the carrier / tracking number propagate back to Amazon.

It also handles your direct physical-product channel: shipping addresses, carrier tracking, delivery status -- the same pipeline whether the order came in through Stripe or Amazon.

What's not covered (today): eBay, Etsy, Walmart Marketplace, TikTok Shop. Multi-channel coverage is Amazon-first. The order pipeline is provider-agnostic, so adding a second marketplace is a registration of a new provider rather than a re-architecture.

The integration argument: Multi-channel SaaS pricing scales with order volume; Indie Legs runs on your $5/month server regardless of whether you ship 10 or 10,000 units a month.


vs The Indie Suite (Indie Legs + Indie Arms together)

Indie Legs is the licensing backend. Indie Arms is the customer-facing storefront that runs on top of it.

You don't have to use both. Indie Legs has its own admin console and works fine standalone. But the typical complete deployment is:

  • Indie Legs for licensing, distribution, webhooks, EDI
  • Indie Arms for the customer storefront, checkout, customer accounts, documentation
  • Caddy or Nginx in front of both for TLS

This combination replaces:

  • Your hosted license server
  • Your hosted storefront platform
  • Your hosted documentation service
  • Your customer portal
  • Your installer build pipeline

All on one server, all under your control, all perpetually licensed.


When We're Not the Right Fit

We've already mentioned a few cases above, but to be explicit:

  • You don't want to run anything. Indie Legs is self-hosted. If running a server is a non-starter, use a managed solution.
  • You need help finding customers, not selling to them. App stores have built-in discovery; SEO/SEM is a different problem. Indie Legs runs email campaigns to your existing list, but it won't get strangers to your storefront.
  • Your customers want to pay you in cryptocurrency / via wire transfer / via PO. Indie Legs supports Stripe and Shopify out of the box. Other payment paths require integration work.
  • You need an audited billing system for SOX compliance. Indie Legs handles licensing and distribution; the financial reporting layer is your accounting system's job.

See Use Cases -- Back to Indie Legs

Content for this section has not been authored yet.