Render Proof

RenderProof’s public landing page introduces the failed-to-approved workflow using evidence from a recorded real-provider run.
A real Genblaze generation fails its composition threshold, receives a targeted prompt repair, and succeeds on the linked retry.
The run inspector exposes the generation prompt, evaluator findings, deterministic delivery steps, rejection reason, and repaired prompt.
The Playground uses the same public /v1 API to create, evaluate, and approve media against a structured Media Contract.
The API Activity view tracks client requests, endpoints, outcomes, latency, related resources, and generation spending.
RenderProof’s versioned API reference documents asynchronous generation, verification, contracts, assets, reports, and provenance endpoints.
RenderProof makes quality decisions, Genblaze orchestrates generation and retry lineage, Backblaze B2 preserves the complete evidence trail.

Inspiration

Generative-media APIs are excellent at producing options, but they rarely guarantee that the first completed result is ready to publish. Images can have incorrect composition, missing requirements, broken branding, unreadable text, invalid dimensions, or unwanted elements.

Teams are then forced to manually inspect outputs, rewrite prompts, retry generations, and reconstruct what happened afterward.

I built RenderProof to turn that manual process into an automated, inspectable quality-control pipeline.

RenderProof is the reliability layer for generative media.

It generates or verifies media, evaluates it against explicit requirements, diagnoses failures, repairs prompts, retries within controlled limits, and returns the strongest approved asset with verified provenance.

What it does

A user or application submits a creative brief together with acceptance requirements. RenderProof converts those requirements into a versioned Media Contract containing:

Required and forbidden visual elements
Output dimensions and aspect ratio
Exact text and reference assets
Brand colours
Quality thresholds
Provider policies
Attempt and budget limits

RenderProof then runs the following pipeline:

Contract → Generate → Evaluate → Recover → Approve

Generate: Image candidates are generated through Genblaze.
Store: Candidates, metadata, and manifests are written to Backblaze B2.
Evaluate: Deterministic checks validate decoding, dimensions, aspect ratio, brightness, colour representation, duplication, and other technical properties.
Inspect: A multimodal evaluator checks every Media Contract requirement individually.
Recover: Failed candidates receive a structured diagnosis. RenderProof repairs only the documented problems and starts a linked retry.
Approve: Hard requirements must pass before candidates can be ranked or approved.
Report: The approved asset is returned with its evaluation report, attempt history, hashes, cost estimate, and provenance lineage.

RenderProof also supports verification-only workflows for assets generated elsewhere. This allows customers to use RenderProof as an independent quality-control API without paying RenderProof for another generation.

API-first architecture

RenderProof is designed as infrastructure rather than only as a standalone image generator.

The dashboard, Playground, recorded demonstration, and run inspector all consume the same versioned /v1 REST API available to developers.

The API supports:

Creating and reusing Media Contracts
Starting asynchronous generation pipelines
Verifying existing assets
Inspecting attempts and rejection reasons
Retrieving evaluation reports
Accessing provenance manifests
Monitoring API activity
Cancelling future retries and spending
Polling and webhook-based integration

The visual interface acts as a playground, operations console, and audit dashboard for the underlying API.

How I built it

The application uses:

Next.js, React, and TypeScript for the public product experience and operations console
FastAPI and Pydantic for the versioned API and validated schemas
PostgreSQL for contracts, runs, attempts, evaluations, and usage metadata
Genblaze for media-provider execution, pipeline orchestration, retry lineage, storage integration, and canonical provenance
Backblaze B2 as the durable evidence store
Pillow and perceptual image analysis for deterministic validation and exact-asset composition
GMICloud Seedream for image generation
Gemini multimodal evaluation through GMI for contract-level visual assessment
Railway for the deployed web application, API, worker, and database services

How Genblaze is essential

Genblaze is the media orchestration layer beneath RenderProof.

Real image generations run through the native Genblaze Pipeline API. Generated assets pass through Genblaze’s object-storage sink into Backblaze B2, where canonical manifests and SHA-256 integrity metadata are preserved.

When RenderProof repairs a failed prompt, the next attempt is created from the previous Genblaze result. This creates parent-child lineage between attempts instead of treating retries as unrelated generations.

RenderProof adds the application layer above Genblaze: Media Contracts, deterministic validation, requirement-level evaluation, recovery decisions, approval policies, and budget enforcement.

How Backblaze B2 is essential

Backblaze B2 is not used only for the final image. It is the durable evidence and provenance store for the complete workflow.

Each run can retain:

Original creative brief and Media Contract
Uploaded reference assets
Prompts and generation parameters
Every generated candidate
Rejected attempts and their evaluation results
Repaired prompts
Approved output
Requirement-level reports
Genblaze canonical manifests
Content hashes and lineage metadata

This creates a reproducible audit trail showing what was requested, what was generated, why something failed, what changed, and why the final result was approved.

Verified recovery demonstration

The recorded real-provider demonstration uses RenderProof run:

gen_6cc9039393ff

It contains two linked Genblaze generation attempts:

Attempt 1 completed but failed the Media Contract because its composition score was 0.90, below the required 0.95.
RenderProof diagnosed the failure and repaired the prompt with more explicit composition, hierarchy, and safe-edge instructions.
Attempt 2 reached the required 0.95 composition score and was approved.
The final weighted score was 0.975.
The run produced 21 evidence objects in Backblaze B2.
Both canonical Genblaze manifests were verified.
The configured generation-cost estimate was $0.07.

The demonstration is based on a genuine provider run. Mock providers are used only in automated tests and are explicitly identified.

Challenges I faced

The hardest challenge was preventing the evaluator from becoming an unreliable approval authority. Model responses are treated as untrusted input, validated against strict schemas, and combined with deterministic checks and hard Media Contract requirements.

Exact text and logos presented another problem because generative models cannot reliably reproduce them. RenderProof preserves exact assets and can add them through a deterministic composition step before evaluating the completed result.

I also needed to connect application attempts, Genblaze run lineage, B2 objects, evaluations, repaired prompts, and final reports without losing provenance across retries.

Finally, external providers can time out, return incomplete metadata, or temporarily become unavailable. RenderProof therefore enforces bounded attempts, cancellation, failure states, idempotency, and explicit degraded results.

What I learned

The durable value is not tied to a particular image model. Providers and generation models will continue to change.

The stable layer is the contract describing what must be delivered, the process that checks it, and the evidence proving that it passed.

I also learned that verification can be valuable independently from generation. Many teams already have generation infrastructure but still need consistent, automated acceptance testing before media reaches customers.