subinc labs
Software development company

We build software,and we runwhat we build.

Two lines that feed each other. We develop software end to end for clients, and we build products we own and operate.

Start a conversationWhat we take on
Founded
2025
Entity
Delaware C Corp
Lines
Services · Products
First product
subinc
The claim

The products are the proof of the services.

Most development shops answer “can you actually build?” with case studies from clients who cannot be named. We would rather answer it with a system you can open: a multi-tenant billing platform carrying a double-entry ledger, built to our own standards and operated by us.

Two lines

One pays for the other’s independence. Both are held to the same standard.

01Services

We build for clients

End-to-end software development and outsourcing. Architecture, implementation, and the unglamorous parts — migrations, observability, the failure modes — carried through to production rather than handed over at the demo. Delivered as a project, as engineers embedded in your team, or as a consultation that keeps you free of vendor lock-in.

  • Backend and infrastructure
  • Systems that handle money
  • Web applications
  • DevOps and cloud migrations
  • Consultation without vendor lock-in
  • Taking over existing systems
  • Dedicated engineers, embedded
What we take on
02Products

We build for ourselves

Software we own and operate, not client work with our name on it. subinc — multi-tenant billing infrastructure — is the first, and it runs on the same standards we bring to an engagement.

  • Owned and operated
  • Built to our own standards
  • subinc is live in private beta
  • More on the same chassis
See the portfolio
The first product

subinc

Multi-tenant subscription billing, metering and revenue on one double-entry ledger, with the payment processor behind an adapter rather than wired through the product.

Double-entry ledger
Debits equal credits on every write, in minor units.
Gateway-agnostic
The processor is a config value, not a re-platform.
Multi-tenant isolation
Enforced at the database, not in application code.
Test and live separated
A hard boundary that batch jobs respect.
Open the product sitesubinc — a subinc labs product.

subinc is in private beta. We run it; it is not yet generally available.

The evidence

Anyone can write “the books never drift”. Here they are.

General journalIllustrative amounts · real mechanism
je_01Invoice finalised — 1 seat, monthly
Accounts receivable$49.00
Deferred revenue$49.00
je_02Payment captured — card
Cash$49.00
Accounts receivable$49.00
je_03Processor fee
Payment fees$1.72
Cash$1.72
je_04Revenue recognised — period elapsed
Deferred revenue$49.00
Subscription revenue$49.00
Total$148.72$148.72
Debits − credits$0.00

Every entry balances, or it is not written

The totals beside each column are summed from the postings above them, and the difference is subtracted, not typed. Nothing here is a screenshot of a good day.

The entries arrive whole, both sides at once — animating one column ahead of the other would put the books out of balance on every intermediate frame, which is the exact drift the claim denies.

Money is never a float

Both results are computed live. The left column runs the real arithmetic and prints whatever it gets.

Floating point
0.1 + 0.2
= 0.30000000000000004

Not 0.3. Every addition carries the error forward, and an audit finds it months later.

Minor units
10 + 20
= 30 → $0.30

Integers all the way through. Formatting happens once, at the edge.

The divisor is not always 100 — USD has 2 decimals
Hardcoded ÷ 100
19.99
Exponent from the currency
$19.99

Same 1999 minor units. A fixed divisor is a 100× error on yen and a 10× error on dinar — the kind that only surfaces once real money has moved.

The processor is a config value

Change it. The adapter swaps; the posting does not move, because there is only one of it.

Swap the processor
Gateway adapter — changes
// adapter
stripe.PaymentIntent.create
// provider reference
pi_3QxT…
Ledger posting — identical
Cash$49.00
Accounts receivable$49.00

Rendered from one constant, shared by every processor above.

How we work

Four commitments we hold to on every engagement.

01

Correctness before surface

A polished interface over a ledger that drifts is worse than nothing — it hides the problem until an audit finds it.

02

Prove, don't claim

We show the mechanism doing its job. A figure on a page is one we can point at in the source that produced it.

03

The failure modes are the work

Retries, replays, partial outages and currency edges are where the engineering lives, and where the cost of being wrong is real.

04

No leverage traded away

We avoid dependencies that are hard to leave, and prove a seam is real by replacing what sits behind it.

What each one costs us

Tell us what you are building.

A short description of the problem is enough to start. We will tell you plainly whether it is something we should take on.

Get in touch