Written by Introduction
Indie makers often live in the “small but real money” zone.
You’re shipping MVPs, building internal tools, creating templates, designing landing pages, offering small consulting packages, doing quick audits. It’s valuable work, but it doesn’t always justify spinning up a full invoicing system.
If you’ve ever delivered a Notion template or a small code change and then waited weeks because your client wanted “an invoice,” you’ve seen the mismatch: modern digital work, old payment workflows.
Payment requests make the workflow match the work.
The Typical Workflow Problem
The common indie maker workflow:
- Build the thing (template, micro-tool, landing page)
- Deliver via link
- Send an invoice (or ask “how should I bill?”)
- Wait
- Follow up
Friction points:
- The client wants a link, not an invoice
- The amount is small enough that finance doesn’t prioritize it
- International payments add complexity
- You lose momentum switching between maker mode and admin mode
This is why people search “get paid online freelance” even when they’re selling a product-like deliverable.
The real problem: payment is not a “step”
Indie projects move fast. If payment isn’t a step you execute at a specific moment, it becomes a vague future event.
The simplest fix is to define one “closing moment” for every deliverable:
- Delivery message sent
- Payment request link included
That’s your default.
Payment Requests (Instead of Invoices)
Payment requests are a simple alternative:
- Create a payment request for the deliverable
- Send the link
- Client pays
It’s effectively a freelancer payment link you can drop into an email or DM.
What to name the request
Make it obvious and forwardable:
- “Landing page build (v1) + deployment”
- “Notion template customization”
- “API integration patch (2 hours)”
When the label is clear, it’s easier for the client to approve internally and easier for you to request payment from client without a long explanation.
When to ask for payment (two simple patterns)
- After delivery: best for trusted clients and clear deliverables.
- Split payments: for larger scopes, send a payment request per milestone (e.g., kickoff, first version, final).
You don’t need complex contracts to do this—you just need a consistent habit.
Handling scope creep (without turning it into drama)
Indie work often starts small and expands. When scope changes, keep it simple:
- Confirm the new request in one sentence
- Send a separate payment request for the add-on
This protects your time and keeps your client comfortable because they always know what they’re paying for.
Gitpay Payment Requests (Natural Fit)
Gitpay allows service providers to generate a payment request link and share it with clients.
- Gitpay homepage: https://gitpay.me
- Gitpay payment requests (service payments): https://gitpay.me/#/use-cases/service-payments
Treat it like your “default checkout” for one-off deliverables.
A forwardable message template
If your client needs to forward to someone else, keep it short:
- Delivered: (1 line)
- Amount: (1 line)
- Payment link: (link)
That’s enough for approval.
Example Use Cases
1) Indie maker delivering a micro-tool
Deliverable: “Internal dashboard script + documentation.”
Send the docs + link together.
2) Landing page + copy polish
If you package landing pages as a service, payment requests are a clean way to charge clients online by milestone.
3) Template pack customization
When someone wants a custom version of your template, use a payment request to close the sale without building a billing pipeline.
4) One-hour advisory call
Indie makers often do quick calls. A payment request is the simplest “pay now” step.
5) Small automation / Zapier-style setup
Deliverable: “Automation setup + handoff notes.”
This kind of work is valuable but often treated like a quick favor. A payment request helps you keep it professional:
- Deliver the automation
- Share the handoff notes
- Include the payment link to close it out
Why This Workflow Is Simpler
Payment requests fit indie work because indie work is lightweight:
- No complex invoicing software needed for small projects
- Fast payment because the link is the action
- Better for international clients
- Works for digital deliverables and small service packages
- Keeps you shipping instead of chasing admin
One-minute checklist for indie deliverables
Indie work gets delayed when your client isn’t sure what they’re paying for. Before sending a payment request, include:
- Deliverable name (clear and specific)
- What’s included (2–3 bullets)
- Delivery method (link, access, repo)
- Payment request link
That’s enough to get approval without long explanations.
The “deliver + pay” rule
If you want a simple habit:
- Every time you deliver, include the payment request link in the same message.
Consistency beats persuasion.
If you want to make it even smoother, mention the payment link early in the project (“I’ll send the payment request with the final handoff”). That way the last step isn’t a surprise.
Common objections (and replies)
- “Can you invoice us?” → “Sure—do you need it to pay, or just for records? Here’s the payment link so it’s easy to process.”
- “We can only pay next week.” → “No problem. Here’s the link—use it whenever you’re ready.”
- “Who should handle this?” → “Whoever processes contractor payments; the label includes the deliverable.”
CTA
If you want to simplify how you get paid for digital deliverables, try creating a payment request on Gitpay:
- https://gitpay.me
- https://gitpay.me/#/use-cases/service-payments
