I build AI-native operations infrastructure for property management companies. DocRunner is the signing tool we built for our own clients because nothing on the market fit the way their workflows actually run.
You can describe a leasing pipeline, a client onboarding flow, or a vendor portal to Claude Code on a Friday and have it running by Sunday. The application layer is yours now. So the question isn't "can I build this." It's "should I."
Most of it, yes. A few specific pieces, no. Here's the test I use, and why signing is on the wrong side of it for anyone who builds their own systems.
The test
Will someone outside your company ever hold this piece of software accountable? A judge. An auditor. A regulator. A carrier.
If no, build it. Your workflows, your intake, your dashboards, your internal tools. Nobody is ever going to subpoena your renewal pipeline. If it's wrong you fix it on Tuesday.
If yes, buy it. Payments, because of PCI and chargebacks. Text messaging, because the carriers register and police every number. Anything that touches trust money, because it gets audited. And document signing, because the thing you had someone sign is going to end up in front of a judge.
Why signing is a buy
Walk into an eviction hearing, or a contract dispute, with an agreement that was signed through a form you built last month.
The other side's attorney doesn't argue about the terms. They argue about the signature. Who signed this? When? How do you know it was them? Did they agree to sign electronically before they signed? Has the document changed since? Where's the record?
Those questions have answers under the ESIGN Act and UETA, and the answers are not "we stored a PNG of a scribble." They are consent captured before the first document opened, a timestamp and IP address on every event, email verification on every signer, and a cryptographic hash of the final PDF so anyone can prove it hasn't been touched. Packaged in a certificate you can hand across the table.
Certificate of Signature: every signer, every timestamp, IP, consent, and the document hash
You could build that. You could also build your own payment processor. The moment it matters, you'd be defending your own code in a courtroom instead of pointing at a vendor whose whole job is this. Bad trade for something that touches maybe a hundred lines of your app.
So buy signing. The question is what kind.
Buy a primitive, not a platform
Most signing tools are sold as platforms. A dashboard. Seats. A place a team logs in to send things by hand. Per-envelope allowances. The API on a separate plan with a sales call in front of it.
None of that fits something you built. Your app has no seats. It doesn't know how many documents it will send next month. It doesn't need a dashboard, because the dashboard is the thing you built. It needs one call that sends the documents, tells you when each person signs, and hands back the signed PDF and the certificate.
That's a primitive. Stripe is a primitive. Twilio is a primitive. You don't log into them to do your work. Your system calls them, and they handle the part that would get you in trouble.
DocRunner is a signing primitive. Specifically, a packet signer.
What a packet signer is
Real-world signing is rarely one document. A lease is a lease, a pet addendum, a move-in report, and a disclosure. A hire is an offer, an NDA, and an IP assignment. Two people sign all of it, then a third countersigns two of them, and the names, dates, and amounts on every page have to match your record.
A packet signer takes the whole bundle as one unit. You define it once: which documents, who signs what, in what order, which fields fill from your data.
Move-In Lease Packet: four documents, Tenant signs first, Owner second
Then your system sends it with one request:
POST https://app.docrunner.io/api/packets
{
"packet": {
"packet_template_id": 50,
"roles": {
"tenant": [{ "name": "Jordan Alvarez", "email": "[email protected]" }],
"owner": [{ "name": "Harbor Point Holdings", "email": "[email protected]" }]
},
"variables": { "monthly_rent": "$1,850.00", "lease_start": "November 1 2026" }
}
}
Signers get one link. No account. They type their name once and it's used for every signature in the packet. As each person signs, a webhook hits your app. When the last one signs, your app fetches the signed PDF and the certificate and files them wherever your record lives.
One packet: status, who has signed, and the values that filled the documents
Your code never touches a PDF. Your workflow never stops at the signature. And when the document ends up in court, the part that matters was handled by something built for exactly that.
Try it
If you're building anything that ends in a signature, this is the part I actually want.
Paste developer.docrunner.io into Claude Code, Cursor, or whatever you're building with, and tell it to add DocRunner signing. Build one packet. Have it identify and place all variables in your PMA or Lease Agreement. Send it to yourself in test mode, which sends no email and hands you the signing links directly. Sign it. Watch the webhook land.
Webhook events your app can subscribe to
It's $40 a month, flat. Unlimited documents, signers, templates, and users. API and webhooks included. No sales call, no seat math, no overage line on the invoice. There's a 90-day trial at docrunner.io.
And if you build something good with it, tell me. I want to see what people wire this into.
- Rob
Our preferred stack for growing PMs":
monday.com | the workspace layer. Where your workflows, boards, and team live.
Aircall | the phone layer. Modern calling with AI built in, on rails someone else maintains.
DocRunner | flat-rate e-signing, built natively inside monday. $40/month, unlimited signatures.
Some of these are partner links. We recommend them because they're what we run and deploy for clients, and the commissions don't change what we'd tell you to buy.