Engagements

Five ways to work with us

Every engagement starts the same way: one discovery call, then a written proposal with scope, team shape, timeline, and investment. Pick the model that matches where your product is.

AI Opportunity & Architecture Sprint

2–3 weeks

Teams who know AI should be in the product but need an engineering answer, not another deck.

A focused assessment of where AI genuinely earns its place in your product — and the architecture to get it there. You leave with a plan your own engineers could execute.

Opportunity map ranked by user value and technical feasibility
System architecture for the first AI feature, including retrieval and data requirements
Evaluation strategy: how quality will be measured before and after launch
Cost model for inference at your projected usage

Most common starting point

Production AI Pilot

4–8 weeks

Teams with a validated AI use case that now needs to survive real users.

One AI capability — a copilot, document pipeline, or workflow automation — taken to a first production release: evals, guardrails, fallbacks, and cost controls included, deployed on your infrastructure.

A production AI feature on your own domain and infrastructure
Evaluation suite with regression tracking
Guardrails, fallback paths, and human-review workflow where the use case requires one
Observability: quality, latency, and cost dashboards

Product Modernization Sprint

Assessment first, then scoped sprints

Teams carrying a codebase that fights back — inherited, aging, or scaled past its design.

A structured takeover of an existing system: assessment of architecture, dependencies, and risk, followed by scoped modernization sprints that improve the platform without freezing the roadmap.

Written assessment: architecture, dependency risk, test coverage, and infrastructure
Prioritized modernization plan with effort estimates
Executed sprints: CI/CD, observability, migrations, and targeted refactoring
Runbooks and documentation your team keeps

Embedded Engineering Pod

Monthly, minimum one quarter

Products that need sustained senior capacity without growing permanent headcount yet.

A dedicated pod of senior engineers embedded in your tools, your standups, and your roadmap — shipping alongside your team with the continuity of people who stay.

Dedicated senior engineers aligned to your roadmap and release cadence
Work in your repositories, project tracker, and Slack — no black-box delivery
Weekly demos and written progress updates
Quarterly planning aligned to your product goals

Long-Term Platform Partnership

Ongoing, month to month

Teams whose product is live and now needs to stay fast, secure, and moving.

The engagement most of our client relationships become: ongoing ownership of platform health — roadmap work, reliability, performance, and incident response from the team that already knows the code.

Prioritized backlog you own, executed at a predictable monthly cadence
Monitoring, on-call response, and incident runbooks
Performance, security, and dependency upkeep
Pause or adjust with two weeks' notice

Investment

What determines the number

We price from scope, not from a rate card taped to the wall. After discovery you get a written figure — fixed for sprints and pilots, monthly for pods and partnerships.

Scope and system surface

A single AI feature, a full product, or a platform takeover — the breadth of the system determines the team shape.

Data sensitivity and compliance context

Healthcare and fintech work carries review, audit, and documentation obligations that are part of the engineering, not overhead.

Existing codebase condition

Greenfield moves faster than takeover. An assessment tells both of us what we are actually working with before anyone commits.

Team shape and duration

A two-week architecture sprint and a year-long embedded pod are priced differently for obvious reasons — cadence and seniority set the run rate.

How we deliver

A process that produces artifacts, not status meetings

Four phases, each ending in something written you can hold us to — a brief, a system design, a weekly staging demo, a runbook.

01
Product brief
Discovery
A short call and a written brief. Goals, users, success criteria, and any data or compliance considerations — captured before anyone estimates anything.
- Goals, users, and success metrics in writing
- Sensitive data, integrations, and regulatory context reviewed upfront
- Risks named at the start, not discovered mid-build
02
System design & milestone plan
Architecture
System design, milestones, and acceptance criteria agreed before the first sprint. Written down, so there are no black-box estimates.
- Architecture diagram with the rationale for each technology decision
- Milestone plan with weekly demo dates
- Acceptance criteria for every deliverable
03
Weekly staging demos
Build
Short iterations with code review on every change and a staging environment you can share with stakeholders. Observability wired in from the first deploy.
- Weekly demo on staging — your domain, your real data shape
- Structured logs, traces, and alerts from the start
- Migrations rehearsed against production-shaped data before they ship
04
Runbooks & monitoring
Launch & operate
Staged cutover with monitoring and runbooks handed to your team — then the partnership most clients continue: roadmap work and platform health, month after month.
- Staged rollout with a rehearsed rollback path
- Incident runbook and on-call drill before go-live
- 30-day stabilization, then a smooth handoff to ongoing partnership

Practicalities

Frequently asked

The questions serious buyers ask before signing. Short answers here — we go deeper on the discovery call.

Who owns the code?

You do, from day one. Your repository lives in your own GitHub organisation with you as the owner — we work on branches.

Do you sign an NDA before discovery?

Yes. We have a standard two-page mutual NDA we can send across, or we will sign yours. Just mention it on the discovery call.

How do we find out what an engagement costs?

After one discovery call we send a written proposal with scope, team shape, timeline, and a fixed figure or monthly rate — grounded in the factors above. No pressure tactics, no expiring quotes.

How do you handle billing?

Fixed-scope engagements are split across kickoff, mid-build, and delivery milestones. Ongoing engagements are invoiced monthly on the first. Net-15, wire or ACH. Invoicing questions go to finance@launchstacks.org.

What if we need to pause the work?

Ongoing engagements pause month to month with two weeks' notice. Fixed-scope work ships to the agreed milestone before pausing — that protects both of us.

Can you take over an existing codebase?

Often, yes. We start with an assessment — architecture, dependencies, test coverage, infrastructure — and recommend a path forward. Sometimes that means incremental improvement; sometimes a staged rewrite is the honest answer.

Can you scale the team up if we need more capacity?

Yes. Adding a senior engineer typically takes a two-week ramp. We do not pad engagements with junior engineers to inflate hours.

Do you take equity instead of cash?

No. Cash engagements only. It keeps incentives aligned and lets us focus on shipping rather than negotiating cap tables.

What if our product is not in healthcare or fintech?

Healthcare, fintech, and trust & safety are where we have shipped most often, but the same disciplines carry: if your software has to be right — and supported for years — we are likely a fit.

Did not see your question? Write to info@launchstacks.org or start the conversation.