Software studio · Brooklyn, New York
Plan, build, test, deploy, maintain, repeat.
A studio that takes an idea to a working product and keeps it running long after launch. Discovery costs nothing, the first milestone is fixed in price, and the code and accounts are in your name from day one.
- Live in production
- 4
- In development
- 1
- First milestone
- Fixed
- Code & accounts
- Yours
Products
Software we built, shipped, and still run
Here as evidence rather than as a catalogue. The argument is that the person paged when one of these breaks is the person who would write yours.
01LiveScheduling & CoordinationConverge
“Share one link, everyone marks when they're free, and the best slot rises to the top.”
Converge solves the coordination problem that email was never built for: finding one hour that works across a dozen calendars and four time zones. Guests open a link, paint the times they are free, and a live heat map resolves the group's best slot without anyone tallying responses by hand. Time zones convert automatically, so nobody does arithmetic to answer a scheduling question.
- Guest access with no account required, on every tier
- Live availability heat map that ranks the best slot
- Automatic time zone conversion for every participant
- Calendar export to any client, and read-only Google Calendar sync on paid tiers
Next.jsTypeScriptGraphQLSupabaseStripeReact Nativeconvergemeetings.com- 02In developmentConsumer Fintech
Apsis
“Lock money into your own vault. Nobody — including us — can open it early. On the date you set, it lands back in your bank, with interest.”
Every savings product asks you to trust a policy. Apsis replaces the policy with a timelock: USDC is held non-custodially on Base under a contract that will not release early for anyone, including the people who wrote it. A ten-minute cooling-off window covers genuine mistakes, and after that the date is the date. Balances and fees are verifiable on-chain, so the guarantee is something you can check rather than something you are told.
In active development — not yet open to the public
- Timelock vault with no early-release path for anyone, including us
- Permissionless release — anyone can trigger a matured lock, so nobody depends on us being around
- A lock can be extended but never shortened
- Ten-minute on-chain reversal window for genuine mistakes
SolidityFoundryBaseNext.jsGraphQLPrivyPonderapsisapp.com 
03LiveConsumer Legal TechCollector Audit
“Debt feels like an ocean. Collectors want you to drown. We want you to swim.”
Consumer protection law only helps people who can prove what happened. Collector Audit gives that leverage back: every call, voicemail, text, and letter is logged with a timestamp into a tamper-evident vault, and built-in checks flag contacts that appear to breach the Fair Debt Collection Practices Act. When it is time to act, the workspace produces FDCPA-aligned letters, sends them by tracked certified mail, and exports a structured PDF for an attorney or a regulator.
- Timestamped log for calls, texts, emails, and letters
- Automatic FDCPA violation flagging
- Debt validation, dispute, and cease-contact templates
- Certified mail dispatch with USPS tracking
Next.jsTypeScriptPostgresDocument pipelinecollectoraudit.com- 04LiveDiscovery & Research
Superfluidity
“SaaS discovery is now AI-native.”
Directory listings go stale the day they are published, because they are written once by whoever wanted the traffic. Superfluidity inverts that: an agent crawls the product, captures what it actually sees, and returns a listing in about thirty seconds, then re-crawls weekly so changes surface on their own. Claims are marked verified, failed, or unverifiable against that evidence, and ranking comes from measured activity rather than upvotes — which is the part a directory cannot fake. Browsing is free; the catalogue is readable by machines as well as people, over a REST API and an MCP server.
- Agent crawls a URL and writes the listing in about thirty seconds
- Scheduled weekly re-crawls, so a listing tracks the product rather than the launch
- Claims marked verified, failed, or unverifiable against crawl evidence
- No ranking at all — every sort is a measurement or alphabetical
Next.jsTypeScriptPlaywrightpgvectorClaudeMCPsuperfluidity.ai - 05LivePayments & Digital Goods
Link Drop
“Sell access to documents worth paying for.”
Selling a single document usually means standing up a storefront, a payment processor and a delivery mechanism for one file — so most people give the file away instead. Link Drop is the smallest thing that closes that gap: a drop is a file, a price between $1 and $500, and a link. Buyers never register, which removes the step that loses most of them; they pay, a Stripe webhook confirms it, and the server mints a signed download URL that expires in sixty seconds. Sellers are paid on a weekly schedule after a short clearing hold, because chargebacks arrive long after the sale does.
- One link per drop — buyers pay without creating an account
- Documents only: PDF, TXT, CSV, MD, XLS/XLSX and PPT/PPTX, up to 25 MB each
- Prices from $1 to $500, with buyers grandfathered at what they paid
- Seller keeps 80%; no listing fee, subscription, or payout minimum
Next.jsTypeScriptApollo GraphQLSupabaseStripe ConnectRedux Toolkitlinkdropapp.com
The work
What building software actually is
Six disciplines, and the unglamorous majority of each. Written for somebody who has not commissioned software before, because the parts that decide whether it succeeds are rarely the parts that get demonstrated.
- 01
Product and scoping
Turning a want into something buildable.
Most software that fails was built correctly and should not have been built. This is the work of finding the constraint nobody mentioned, deciding what is genuinely in the first version, and writing it down in language you can hold us to. It is mostly conversation and mostly unbillable, which is why discovery is free — it is also where the money is either saved or wasted.
- Discovery conversations and a written problem summary
- Scope split into milestones, first one fixed in price
- The explicit list of what version one does not do
- Estimates as ranges, with the assumptions attached
How it shows up in the price
Not a line item. It is the free part before anything is quoted, and what turns the estimate below from a range into a unit count.
- 02
Design
Deciding what it looks like and how it behaves.
Screens, states, and the flow between them. The visible part is the smallest part: the work is the empty state, the error, the half-loaded list, the form somebody submits twice. Designed as a component set rather than a set of pages, because pages drift and components do not — and because the second version has to be cheap to build.
- Interface design for every screen and its states
- A clickable prototype before code, where the interface is the product
- A component library the build is assembled from
- Handoff that an engineer can build from without asking
How it shows up in the price
The design choice in the estimator. Bring your own and it is zero; interface design or a full system add units.
- 03
Engineering
Building it, on the platform that suits the problem.
Web, iOS, Android, desktop, and the backend underneath. Typed end to end, so a change that would break something fails at the keyboard rather than in front of a customer. The platform decision is made from what the software has to do — the local filesystem, offline, a store presence, a browser — rather than from what is fashionable, because it is the decision that is most expensive to reverse.
- Web applications, native and cross-platform mobile, desktop
- APIs, databases, and the integrations to systems you do not control
- Migration and import from whatever it is replacing
- Deployed to infrastructure that can be debugged, not just restarted
How it shows up in the price
The platform choice sets the baseline in units, and each feature package adds to it. Both are priced openly in the estimator.
- 04
AI features
Language models and retrieval, with the evaluation attached.
Putting a model in a product is a week's work. Knowing whether its answers are right is the rest of it, and it is the part that gets skipped — which is how a feature ships confidently wrong. Anything built here comes with a way to measure whether it is behaving, and a stated answer to what happens when it is not.
- Language-model features, retrieval over your own documents, classification
- Evaluation sets, so quality is measured rather than felt
- Cost and latency budgets, because both are per-request
- A defined fallback for when the model is wrong or unavailable
How it shows up in the price
One feature package, at more units than most, because the evaluation half is included rather than optional.
- 05
Quality
Making sure it works, and keeps working after a change.
Not a phase at the end. Types across the whole codebase, tests where the logic is load-bearing rather than everywhere for a coverage number, and a real device and browser matrix. The purpose is not to find bugs before launch — it is that the version after launch can be changed without fear, which is the difference between a product and a liability.
- Typed end to end; a wrong change fails before it runs
- Tests on the logic that decides money, access, or data
- Device, browser and OS matrix appropriate to the platform
- Acceptance passes against the scope, in your hands
How it shows up in the price
Inside every platform baseline, not sold separately. A build without it is cheaper and is not what we sell.
- 06
Launch and operations
Getting it live, and knowing first when it breaks.
Deploys that can be rolled back, monitoring and error reporting configured before the first real user, and store submission where a store is involved. Then the part that decides whether the thing survives its second year: somebody notices the failure who is not your customer. On our own products that person is us, which is the entire reason this argument is made in the first person.
- Deploy pipeline, environments, and a documented rollback
- Uptime and error monitoring live before launch, not after the first incident
- App Store and Play submission, and the review cycle that follows
- Runbook and credentials, in your name from the start
How it shows up in the price
The support choice in the estimator, as a flat monthly figure — including the option where it is zero and you take the keys.
Process
From a conversation to something running
Five phases, each ending in an artefact you hold rather than a status update. Nothing here renews by default and nothing locks you in — at every point the work so far is yours.
Discovery
A conversation about what the software has to do, who uses it, and what happens today instead. Most of this is finding the constraint nobody mentioned — the export that has to keep working, the regulator, the one customer who cannot be migrated.
- You get
- A written summary of the problem, in your words, that you can correct.
- It costs you
- An hour or two of your time. No charge, no obligation.
Scope and first milestone
The work broken into milestones, with the first one fixed in price and small enough to judge. You are buying a piece of working software, not a discovery phase that bills by the hour and ends in a slide deck.
- You get
- A scope document, a milestone plan, and a number for milestone one.
- It costs you
- A decision. If the scope is wrong, this is where it is cheap to say so.
Build, in the open
Work happens against a deployed environment you can open from day one, not a demo at the end. You see it as it is — half-finished, wrong in places, correctable. That is the point: the expensive mistakes are the ones nobody sees until launch week.
- You get
- A running environment, updated as work lands, and a weekly note on what moved.
- It costs you
- Review as you like. Feedback early is worth more than feedback thorough.
Launch
Deployed on infrastructure that can be debugged rather than only restarted, with monitoring and error reporting configured before the first real user arrives — not after the first incident makes the case for them.
- You get
- A live product, the runbook for it, and the credentials in your name.
- It costs you
- A go date, and someone on your side who can answer questions that day.
After launch
Software that is used changes. What breaks first is rarely what anyone predicted, so the arrangement afterwards is deliberately plain: you can keep us on for changes and monitoring, or take the keys and go. Both are normal endings.
- You get
- Ongoing support if you want it, and a clean handover if you do not.
- It costs you
- Whatever you choose, month to month. Nothing that renews by default.
Estimate
What it costs, before you ask
Priced in units of work, not hours. A unit has a published price and costs that whether it takes a day or a fortnight — so the speed is worth something to you and nothing to your invoice. Configure something close to what you have in mind; nothing is gated.
Estimated build$24,600 – $38,400
Where it runs
Runs in a browser, installs nothing, ships whenever you want. The cheapest thing to build and by far the cheapest to change.
How far it goes
The smallest thing somebody would actually pay for or rely on. Accounts, the core workflow, and the paths around it that cannot be broken.
What it needs to do
Sign-up, sign-in, password reset, and roles. Cheap to add now and expensive to retrofit, because everything else ends up depending on who is asking.
Design
We design the screens. Functional, consistent, and built from components rather than drawn one page at a time.
Regulatory
Ordinary good practice: encryption in transit and at rest, sane access control, no secrets in the client.
After launch
We watch it and keep it healthy. No feature work; changes are quoted as they come up.
Estimated build
$24,600 – $38,400
3 weeks to delivery · $3,500 per unit
Units of work
9
- Platform and scope6
- Features1
- Design2
- First milestone, fixed
- $4,500
- Discovery
- Free
- Support, monthly
- $250
Delivered in
Same units of work, same money. Bars are scaled at 5 working days to the week; the lower figure is what the identical scope is normally quoted as.
This is an estimate. A quote comes out of discovery, which costs nothing — and which is also where an estimate like this one usually turns out to have been missing something.
How this compares
New York agencies commonly quote $50k–$150k for an MVP, at $150–$250 an hour, over three to six months.
You are not buying hours here. A unit of work has a published price and it costs that whether it takes a day or a fortnight — so going faster is worth something to you and nothing to your invoice, which is the opposite of how a timesheet works.
That the speed holds is a claim, and a falsifiable one: the first milestone is fixed in price. If it does not hold, we absorb it.
What this number does not include
- Hosting and infrastructure
- Usually tens of dollars a month to start, and it scales with use. Billed to your account, not ours.
- Apple Developer Program
- $99 a year, required to ship to the App Store.
- Google Play registration
- $25 once, required to ship to Play.
- Payment processing fees
- Set by the processor, taken per transaction.
- Third-party API and model usage
- Anything metered — mapping, email delivery, language models — is billed to you at cost.
- Audit and certification fees
- SOC 2 or HIPAA engineering work is priced above; the auditor is a separate firm and a separate cost.
- Domains, email, and licences
- Small, ongoing, and yours to keep — which is the point of them being in your name.
How we engage
Four ways this usually starts
Each begins the same way — a scoping conversation and a fixed first milestone. No open-ended retainer before either of us knows what we are building.
- 01
Idea to product
A full application from discovery to launch, scoped into milestones with a fixed first one — so you can judge the work before committing to the rest of it. This is the route for something that does not exist yet.
UsuallyFounders and operators with a problem they understand better than anyone.
- 02
Internal tooling
The dashboard, importer, or workflow your operation currently runs on a spreadsheet and one person's memory. Usually the highest-leverage software a business can buy, and the least glamorous.
UsuallyTeams whose real system of record is a file called final_v3.xlsx.
- 03
Integration work
Systems that should talk to each other and do not: payment providers, calendars, CRMs, document pipelines, and the glue between them. Built to fail loudly rather than silently.
UsuallyAnyone re-keying the same data into two systems by hand.
- 04
Rescue and continuation
An existing codebase that has outlived its author. First deliverable is an honest assessment of what is there — sometimes the answer is that continuing costs more than restarting, and you should hear that before it costs you a quarter.
UsuallyProducts whose original developer is gone and whose deploys have stopped.
After launch
Launch is the middle. The second year is the test.
Most studios describe what they do before a launch date. This is the part that decides whether the thing survives its second year — and it is stated as behaviour rather than as a service level, because a practice this size cannot promise a response time truthfully.
You own everything
Repository, cloud accounts, domains and data are in your name from the start. Nothing has to be handed over because nothing was ever ours. There is no version of this where leaving is a negotiation.
Monitoring before incidents
Error reporting and uptime checks are configured at launch. The first person who knows something is broken should not be your customer.
The person who built it answers
There is no support tier to escalate through. The engineer who wrote the code is the one who reads the alert, which is the same arrangement we run on our own products.
Changes stay possible
Typed end to end, tested where the logic is load-bearing, and documented enough that a different engineer could pick it up. Software you cannot safely change is a liability wearing a product's clothes.
Next step
Have an idea that needs building?
Tell us what the software has to do and who it is for. We come back with a scope, a first milestone, and a number. Discovery is free and commits you to nothing.
- Free discovery
- Fixed first milestone
- You own the code
- We run what we ship