BidCheck

Turn dense federal solicitations into evidence-linked bid/no-bid decisions in minutes.

Comment

Inspiration

Federal solicitations are dense, repetitive, and unforgiving. A small contractor can spend hours reviewing one opportunity and still overlook a submission instruction, security requirement, eligibility issue, or staffing constraint that changes the bid decision.

I built BidCheck to shorten the distance between receiving a solicitation and making a defensible executive decision.

What it does

BidCheck converts federal solicitation text into an evidence-linked bid/no-bid analysis.

It:

  • Extracts solicitation metadata, deliverables, evaluation factors, and binding requirements.
  • Preserves the original language and assigns stable REQ-### identifiers.
  • Evaluates a versioned federal acquisition-readiness rulebook.
  • Combines solicitation evidence with optional, self-reported company context.
  • Separates opportunity risk from contractor readiness.
  • Produces an executive BID, NO-BID, or BID WITH CONDITIONS memo.
  • Links findings back to the requirements and authorities that produced them.

A central design rule is that absence of evidence is never treated as a deficiency. If a readiness rule applies but the user provides no relevant company information, BidCheck reports not_evaluated instead of inventing either compliance or failure.

How I built it

BidCheck is a Next.js and TypeScript application deployed on Vercel. Its server-side analysis pipeline uses the OpenAI Responses API with GPT-5.6 Sol.

The pipeline has three stages:

  1. Structured solicitation extraction
  2. Rulebook-based readiness analysis
  3. Evidence-linked executive memo generation

The extraction and findings use strict Structured Outputs validated with Zod. Risk, readiness coverage, confidence, and recommendation guardrails are calculated deterministically in application code rather than generated directly by the model.

Results are streamed to the interface as NDJSON stage events. Submitted documents are not intentionally stored by the application, and active results remain in browser session storage.

I used Codex with GPT-5.6 Sol at high reasoning effort throughout the core build. Codex helped translate my initial prompt pack and federal rulebook into the application architecture, implement the streaming route and schemas, build the interface, test failure paths, and identify weaknesses in the original evidence model.

I retained responsibility for the federal-acquisition rules, product scope, risk logic, evidence classifications, and final engineering decisions.

Challenges I ran into

The hardest problem was not generating a memo. It was preventing the system from expressing unsupported certainty.

My original design could identify that a solicitation triggered a readiness rule, but it could not determine whether a contractor satisfied that rule without company evidence. I redesigned the findings around five statuses:

  • satisfied
  • gap
  • needs_review
  • not_applicable
  • not_evaluated

I also separated solicitation-side risk from contractor-readiness coverage. This prevents missing company information from silently becoming a compliance failure or a false claim of readiness.

Other challenges included handling untrusted instructions embedded in solicitation text, validating structured model output, streaming a multi-stage analysis reliably, and protecting a public API-backed demonstration with rate and spending limits.

Accomplishments I’m proud of

I am most proud that BidCheck refuses to manufacture confidence.

An unconditional BID recommendation is structurally unavailable when no company profile is supplied. Each readiness finding must be supported by supplied evidence, and the aggregate decision signals are derived by server-side rules.

The result is more than a document summarizer. It is a transparent decision-support workflow that shows what the opportunity requires, what the contractor has established, what remains unknown, and what leadership should do next.

What I learned

The most important lesson was that trustworthy AI behavior comes as much from system design as from prompting.

Separating model judgment from deterministic calculations, distinguishing missing evidence from negative evidence, and preserving source traceability produced a much more credible application than asking one model call for a bid/no-bid answer.

Codex was most useful as an engineering collaborator when I gave it explicit constraints and challenged its defaults—not when I treated generated code as automatically correct.

What’s next

After the judging period, I plan to benchmark lower-cost models against the same acceptance set before changing runtime routing.

Future possibilities include PDF and DOCX ingestion, configurable organizational profiles, expanded rulebook administration, SAM.gov integration, saved opportunity workspaces, and human-reviewed updates to acquisition authorities.

BidCheck remains decision support—not legal advice or a contracting-officer determination.

Built With

Share this project:

Updates