Method2Model
services & pricing
Choose a clear, defensible path
from a free feasibility check to a reusable decision model and (optional) managed runs
What we deliver
We turn study methods, protocols, and care pathways into explicit, reviewable model logic
then into formulas and reproducible code
so the decisions built on them become defensible before execution, defensible under review, and interpretable after results
Two ways to work with us
Project-based
(most common)
Best when you have a specific protocol, study, or decision deadline. You pay per stage (or a fixed scope) and receive a package you own, built around one clearly defined decision
Subscription
(for ongoing teams)
Best when you run studies continuously and need repeated, decision-focused modeling support across multiple questions, iterations, and datasets.
Not sure which one fits?
Services & pricing at a glance
Lite
Decision Pack
For one clear decision, fast de-risking, and a defensible logic package—without building a full reusable code asset. Starting at $1,900 • Typical range $1,900–$4,900
Standard
Model + Code Pack
For a runnable model with deliverable code your team can execute (or we can run under NDA), so the decision logic can be re-run and inspected, not just described.
Starting at $12,500 • Typical range $12,500–$29,000
Stage-based totals may vary slightly; package pricing includes integration + verification overhead
Advanced
Reusable Verified Asset
For a long-term, auditable decision asset: deeper verification at the code level, a reproducibility pack, and a professional repo structure your lab or team can reuse across studies.
Starting at $29,000 • Typical range $29,000–$75,000
Small note: Bundle discount for Stage 1→3 packages is available (typically 5–10%)
Most teams start with Stage 0, then choose Lite / Standard / Advanced based on whether they need a decision memo, runnable code, or a reusable verified asset
The 4-stage Method2Model path
(our core service)
Purpose: A fast, honest answer on which decision is worth modeling, and how, without sensitive details.
You send: 5–10 lines + non-sensitive summary.
You receive (within ~1 business day):
- Feasibility note
- Suggested use case (1 of 12)
- Minimum inputs list for Stage 1
Price: $0
Purpose: Convert your method into an explicit, reviewable decision structure you can defend.
Deliverables:
- Assumptions Map (MRR) (reviewer-readable, evidence-tagged)
- Model Architecture (inputs → states → outputs)
- Input Spec Sheet (ISS) (variables, units, timing, ranges)
- Scenario Pack v1 (what-if tests)
- Verification Plan (how Stage 3 will prove code = architecture)
Typical use cases: Protocol Blind-Spot Scan, Reviewer-Ready Logic Pack, Real-World Power Check (early), Measurement Decision Design.
Pricing: Starting at $1,900 • Typical range $1,900–$4,900
Purpose: Lock the model mathematically so the way the decision is computed can’t drift during implementation.
Deliverables:
- Formula Pack (equations, boundary conditions, parameters)
- I/O Contract (official schema) (types, shapes, allowed ranges)
- Scenario Pack v2 (formal configs)
Pricing: Starting at $3,400 • Typical range $3,400–$8,900
Purpose: Deliver a reproducible code package and prove it faithfully implements the Stage-1 decision logic.
Deliverables:
- Python Code Package (versioned)
- Runbook + configs (install/run scenarios)
- Verification Evidence (acceptance tests proving code implements the Architecture + Verification Plan)
- Handover note (what to reuse / extend next)
Pricing: Starting at $6,900 • Typical range $6,900–$19,000
Purpose: You own the code. You receive a versioned package + run instructions + configs; if you want, we run it for you under NDA on sensitive data and deliver decision-ready outputs.
Deliverables:
- Simulation outputs (raw + structured)
- Decision notes (1–2 pages, written rationale for what the runs imply)
- Run certificate (code version + config used)
Pricing options:
- Option A (per run / batch): Starting at $950 • Typical $950–$4,500
- Option B (monthly managed execution): Starting at $2,400/month • Typical $2,400–$9,000/month
Managed runs include basic data sanity checks; full data cleaning is scoped separately
Modeling Solutions
(12 Use Cases)
Choose the outcome you need
before you run a study, before you submit it, during execution, or after results raise new questions.
- Protocol Blind-Spot Scan (recruitment, endpoint mismatch, power erosion)
- Real-World Power Check (simulation-based power & sample size)
- Measurement Decision Design (minimal, high-information plan)
- Regimen Robustness & Dose Decision (PK/PD regimen logic)
- Transferability & Scaling Check (animal → human / RCT → real world)
- Reviewer-Ready Logic Pack (make study logic defensible under scrutiny)
- Mid-Study Amendment Decision (lowest-risk adjustment; not replacing clinical judgment)
- Null-Result Next-Step Map (explain divergence and what to do next)
- Result Robustness & Reproduction Check (post-study reproduction & logical validation)
- Hidden-Variable Discovery Pack (model–reality gap mapping; hidden confounders, missing links)
- Care Pathway Reliability Check (bottlenecks, drop-offs, capacity limits)
- Reusable Decision Model Asset (versioned repo + documentation + reproducibility pack)
Academic Track
(University / Thesis)
Built for limited budgets, semester timelines, and publishable, defensible outputs.
(proposal-ready)
Best for: proposal defense, IRB/ethics prep, early methodology lock.
Includes: Stage 0 + Stage 1 (scoped)
You get: thesis-ready Architecture + Assumptions Map + ISS + minimal scenarios + light verification plan — enough to defend your design decisions in a proposal or IRB/ethics review.
Pricing: $690–$1,490
(model + code)
Best for: a full thesis that needs reproducible runs + methods you can cite.
Includes: Stage 1 + Stage 2 + Stage 3 (thesis-scoped)
You get: formulas + reproducible code + runbook + verification evidence — so your thesis decisions are traceable from assumption to result.
Pricing: $2,900–$6,900
(reviewer-proofing)
Best for: papers stuck on interpretation, robustness, or reviewer requests.
Includes: use-case modules (typically 6/7/8/9/10 depending on the situation)
You get: consistency checks, sensitivity notes, reviewer-ready logic pack.
Pricing: $1,400–$4,900
Small note: Academic scope is tuned to thesis constraints without sacrificing traceability and defensibility.
Subscription
(optional)
For teams who model repeatedly across studies, iterations, and datasets.
What it’s for:
- repeated decision-focused use-case support (e.g., power + measurement + mid-study what-if)
- iterative revisions without renegotiating a full project each time
- ongoing model maintenance or reuse across protocols
How it works:
monthly retainer → defined response time + rolling scope + priority queue
Support
$1,900/month
Best for: recurring questions, fast reviews, limited scenario work
Modeling Partner
$4,900/month
Best for: repeated use-case work + real iteration + light maintenance
Lab/Team Retainer
$9,500/month
Best for: multiple parallel threads, priority queue, deeper model/code continuity.
What we need from you (inputs)
We don’t need identifiable data to start. Most decision-focused work begins with:
- protocol / study summary
- endpoint definitions + timing
- constraints (sites, recruitment reality, measurement limits)
- a variable dictionary (even if rough)
Adding multiple use cases
(official rule)
Scenario Add-on
(same architecture)
If a new request adds scenarios, sensitivity checks, or reporting without changing architecture: $450–$1,900 (typical)
Scope Extension
(architecture changes)
If a new use case changes the architecture (new state, new endpoint logic, PK/PD layer, new pathway structure, etc.), we reopen the lock:
- Stage 1 Re-lock: $900–$2,900
- Stage 2 Re-formalize: $1,400–$4,900
Ready-to-use sentence for the page
Use cases can be added either as Scenario Add-ons (same architecture) or as Scope Extensions (architecture changes). We confirm which one applies before quoting.
Data, IP, and privacy
- Stage 0 is anonymous and requires no NDA.
- From Stage 1 onward, NDAs and data-processing agreements (DPA) are available when appropriate.
- What we publish (by default): we may publish sanitized, non-identifiable assets that support transparency and reproducibility—e.g., generic model structure, reusable code components, synthetic examples, and high-level descriptions of what a model answers.
- What we never publish (by default): your study data, identifiable information, confidential protocol details, internal documents, or anything that can reveal your project identity or sensitive IP.
- Opt-out (client privacy mode): if you want no public release at all (including generic code/templates derived from the work), request this at Stage 1. This may affect scope, timelines, and pricing because it changes how we build and document the deliverables and how future decisions can reuse them.
Payment & Delivery notes (short)
- Typical payment structure: 50% kickoff / 50% on delivery (per stage)
- Expedite option for tight deadlines: +25%
- Pricing is in USD (a USD/EUR toggle can be added)
Not sure which stage fits your situation?
Start with a free feasibility check, and we’ll suggest the lowest-effort path to a defensible decision.
