Healthtech MVP Text-to-Image API: Cost per Image Under a Quality-Latency Gate

Short answer: don't choose the cheapest image generation API from its list price. For a healthtech startup MVP, measure cost per accepted image only after the image clears a quality gate and the request fits the latency budget. The moderation-report classifier remains the safety-critical path; generated images should be an isolated, optional part of the product until their quality and timing are understood.

That distinction matters. A moderation report is not a picture, and an image API should not quietly become the decision-maker for a report that needs human review. The useful experiment is narrower: can text-to-image generation create consistent, de-identified visual material around the workflow without delaying classification or exposing sensitive content?

This is an experiment note, not a price ranking. Freeze the prompt set, the output settings, the acceptance rule, and the latency target. Run the same corpus through each candidate, count every billed attempt, and keep the rejected outputs. Only then is cost per image a number worth comparing.

What should a startup MVP measure before comparing image generation API cost per image in Node.js?

Start with the product boundary. The classifier receives a moderation report and returns a category for human review. The image path can turn an approved, de-identified summary into a visual aid, but it must not receive raw patient identifiers or alter the report category. Give the two paths separate queues, budgets, logs, and failure handling.

The acceptance rule needs to be written before anyone sees the outputs. For this scenario, it might require the requested subject, a permitted style, the correct aspect ratio, no identifying text, and a reviewable result within the agreed latency target. A file that needs another generation is rejected. A file that is attractive but contains an identifier-like label is rejected too.

Use this denominator:

cost per accepted image = total generation spend / accepted images

Do not substitute cost per request. The latter hides retries, duplicate clicks, rejected compositions, and outputs that a reviewer cannot use. I record a 429 separately from a content rejection because those events point to different operational decisions. One is capacity or rate policy; the other is a quality or prompt problem.

The corpus should be small and real enough to be uncomfortable. Include the visual briefs the MVP actually needs, plus a few adversarial cases: a long clinical description, a request that could reveal identity, and a prompt containing text that must not appear in the image. Don't include live sensitive reports. Redact them first, and preserve the redaction step as part of the test harness.

Keep it boring.

I'm not sure a public pricing page can tell you which candidate will be cheapest for this workflow. It can tell you how a quote is expressed at a point in time; only your acceptance rule tells you how much usable output you received.

A small Node.js ledger makes the comparison auditable

The following TypeScript code is deliberately provider-neutral. It assumes that the request runner has already captured the billed amount, decision, and elapsed time for each attempt. That separation is useful: the API adapter can change while the calculation stays reviewable.

type Attempt = {
  candidate: string;
  billedUsd: number;
  accepted: boolean;
  latencyMs: number;
  statusCode?: number;
};

type Summary = {
  attempts: number;
  accepted: number;
  spendUsd: number;
  latenciesMs: number[];
  rateLimited: number;
};

const attempts: Attempt[] = [
  { candidate: "candidate-a", billedUsd: 0.01, accepted: true, latencyMs: 1800 },
  { candidate: "candidate-a", billedUsd: 0.01, accepted: false, latencyMs: 2100 },
  { candidate: "candidate-b", billedUsd: 0.01, accepted: true, latencyMs: 2400 },
  { candidate: "candidate-b", billedUsd: 0, accepted: false, latencyMs: 900, statusCode: 429 },
];

const summaries = new Map<string, Summary>();

for (const attempt of attempts) {
  const summary = summaries.get(attempt.candidate) ?? {
    attempts: 0,
    accepted: 0,
    spendUsd: 0,
    latenciesMs: [],
    rateLimited: 0,
  };

  summary.attempts += 1;
  summary.accepted += Number(attempt.accepted);
  summary.spendUsd += attempt.billedUsd;
  summary.latenciesMs.push(attempt.latencyMs);
  summary.rateLimited += Number(attempt.statusCode === 429);
  summaries.set(attempt.candidate, summary);
}

for (const [candidate, summary] of summaries) {
  const ordered = [...summary.latenciesMs].sort((a, b) => a - b);
  const p95Index = Math.max(0, Math.ceil(ordered.length * 0.95) - 1);

  console.log({
    candidate,
    attempts: summary.attempts,
    accepted: summary.accepted,
    costPerAcceptedUsd:
      summary.accepted === 0 ? null : summary.spendUsd / summary.accepted,
    p50LatencyMs: ordered[Math.floor((ordered.length - 1) * 0.5)],
    p95LatencyMs: ordered[p95Index],
    rateLimited: summary.rateLimited,
  });
}

The decimal values above are test fixtures for the calculator, not current provider prices. Replace them with observed billed amounts from a fixed run. Store the model identifier, dimensions, quality setting, prompt version, redaction result, and reviewer decision alongside each attempt. Without those fields, a later run can look cheaper simply because it used an easier brief.

The ledger also needs an explicit duplicate-request policy. A user clicking twice may create two billed generations, but that is not the same failure as a rejected image. Count both. Fix the interface or queue behavior separately from the model comparison.

How does the quality-latency gate change the text-to-image API decision?

Price should be a tie-breaker. First remove candidates that fail the safety and usefulness checks; then remove candidates that miss the response-time target; only after that compare spend per accepted result. This keeps a cheap but unusable output from winning by denominator trickery.

For the healthtech workflow, the gate can be expressed as a small decision table:

This is where the reader's four named candidates can be compared without pretending that a universal winner exists. Put OpenAI, Stability, Ideogram, and fal behind the same adapter contract if they are on the shortlist. Give each the same prompt corpus and record the same fields. The names are less important than the evidence: acceptance rate, latency distribution, rejected-content reasons, and billed attempts.

The simple approach fails when “one image returned” is treated as success. In a moderation workflow, a returned file may still be unusable, unsafe to display, or too slow for the user journey. A quality-latency gate exposes that difference before the API choice gets embedded in application code.

Where does a gateway or abstraction stop fitting?

A generic adapter can protect a solo team from rewriting the whole application when a candidate changes. Keep the interface small: accept a versioned prompt, dimensions, and an operation identifier; return an image reference, measured latency, and a review decision. That is enough for an MVP ledger.

The catch is the dependency surface. An abstraction is not suitable when the product needs provider-specific controls that the common interface cannot express, when direct procurement is mandatory, or when an extra gateway makes latency harder to explain. Stick with a native integration in those cases. A self-hosted gateway such as LiteLLM is another option when the team accepts deployment and maintenance work in exchange for a common boundary; it still does not decide which output is acceptable.

The same rule applies to adjacent capabilities. Cohere's Rerank documentation describes ranking as a separate capability, which is a useful reminder not to assume that one image interface also solves report classification, moderation, or retrieval. Keep classification and generation as explicit stages with independent tests. A broad API catalog is not an architecture.

The shipping rule for this MVP

Ship the candidate that passes the quality and latency gates with the smallest measured operational burden. Use cost per accepted image to break a close call, not to override a failed gate. Start the image feature behind an opt-in or non-blocking workflow, and keep the human review boundary visible in the data model.

I would rerun the corpus after changing a model, image size, quality setting, prompt template, or queue policy. Your mileage may vary because acceptance is specific to the product's visual briefs. The durable artifact is the ledger and its decision rule, not a static “cheapest API” list.

References

• Cohere Rerank documentation: https://docs.cohere.com/docs/rerank-overview
• LiteLLM, self-hosted LLM gateway: https://github.com/BerriAI/litellm