Govafy.
The project behind it.
Turning government data and organizational knowledge into a connected workspace. A project by Abraham Xiong.
Explore the architecture30M+
Award records ingested
Large-scale data ingestion is one foundation. The other is making documents and knowledge useful in context.
Industry experience, made into software.
What it is
Govafy brings opportunity research, capture, proposal work, relationships, and company knowledge into one GovCon workspace. Govie is the AI assistant that connects that context to the work at hand.
This site presents Govafy as an engineering project and a record of what I am building and learning. Public signup is closed.
Why I built it
Working alongside government contractors showed me how much time disappears between disconnected systems. Award histories, solicitations, past performance, and relationships all matter, but they rarely arrive in the same place.
Govafy is my exploration of that problem: how to turn industry knowledge into useful software, with enough context and traceability for a person to review the result.
Two paths into a shared workspace.
Structured award records and unstructured documents need different treatment. Explore how each becomes useful context.
Structured data follows an ingestion and relational-query path. OCR is not needed for award CSV records.
Government data
USAspending bulk award downloads provide ZIP and CSV inputs. Opportunity feeds complement the award history.
Ingest & normalize
Stream parsing and batch upserts load records, with recipient identifiers linking awards to contractor entities.
Store & query
PostgreSQL supports structured search and relationships between awards, contractors, agencies, and opportunities.
Use in context
Research and workspace features bring relevant records into the contractor’s workflow.
Data ingestion at real scale.
Over 30 million award records have been pulled into Govafy. The engineering challenge is making that volume usable.
From government feeds to records
USAspending bulk downloads are streamed from ZIP and CSV files, parsed in batches, and upserted into PostgreSQL. Recipient identifiers connect award records to contractor entities. SAM.gov and GovConAPI integrations bring opportunities and attachment metadata into the broader data system.
Repeatable work, visible progress
Long imports need bounded concurrency, retries, progress tracking, and cancellation. Normalization and duplicate handling are part of the work, alongside loading records. An ingested award record is not the same thing as a fully parsed or embedded document.
RAG that starts with the source.
Retrieval-augmented generation gives an AI model relevant source material before it answers or drafts.
Retrieve the right context
Govafy combines keyword retrieval with vector search where embedding coverage is sufficient. Reciprocal rank fusion combines the rankings. Organization and project scope narrow which source material is eligible to enter the context.
Keep the evidence connected
Documents are extracted, divided into chunks, and indexed with their source relationships. Retrieved material supports grounded research and proposal work. Source references help a reviewer return to the evidence; retrieval does not remove the need to check an AI-generated claim.
Why not send the entire library to a model?
Large libraries exceed useful context budgets and mix relevant facts with unrelated material. Retrieval focuses the input, while scope checks reduce the risk of pulling information from the wrong organization or project. The quality of extraction, chunking, and ranking directly affects the quality of the answer.
OCR is a pipeline, not a checkbox.
Government documents arrive as digital PDFs, scans, spreadsheets, and Office files. Each needs a suitable processing path.
Check the file
Preflight checks and ClamAV scanning gate which documents can move into extraction and AI use.
Extract or recognize
LiteParse handles digital PDFs first. Local Tesseract OCR and Google Document AI fallback address scanned content when needed.
Prepare for retrieval
Extracted text is checked and chunked. Eligible content can be embedded and indexed while keeping its source association.
File size, timeouts, OCR cost, and deferred work are explicit concerns. Not every downloaded document is ready for retrieval.
The tech stack, with a purpose.
The application architecture spans data systems, AI, document processing, and the interface people use to review the work.
Application & interface
TypeScript / React / Vite
TypeScript connects frontend work to backend contracts. React and Vite power the application, with Tailwind CSS, Radix UI, TanStack Query, and Zustand supporting the interface and its state.
Backend & infrastructure
Encore.ts / Google Cloud
Typed services and background jobs are built with Encore.ts. The deployment configuration uses Google Cloud Run, PostgreSQL, Cloud Storage, and Cloud Scheduler, with separate workers for intensive document processing.
Data & retrieval
PostgreSQL / pgvector
Relational tables connect awards, contractors, agencies, and opportunities. Full-text indexes and pgvector support keyword and semantic retrieval over eligible content, with organization and project boundaries applied to source selection.
AI & orchestration
OpenAI / AI SDK
OpenAI models and embeddings sit behind an AI gateway. The Vercel AI SDK supports model interactions, while retrieval supplies context for research and proposal workflows. Human review remains part of the process.
Documents & OCR
LiteParse / Tesseract / Document AI
Digital text is extracted first. Scanned PDFs can use local Tesseract OCR, with Google Document AI as a fallback. Mammoth and Office-file parsers handle additional formats; ClamAV gates document consumption.
Workspaces & identity
Clerk / React Flow / DOCX
Clerk provides identity integration. React Flow supports visual workflows, while document export libraries carry work into Word and other Office formats. Retrieval and backend checks keep context scoped to the relevant workspace.
My contribution.
I architected Govafy and lead its development from product requirements through implementation, verification, and release. Claude Code, Codex, and Cursor are part of how I build it.
Architecting the platform
I translate government-contracting workflows into the platform’s architecture: the data model, service boundaries, ingestion pipelines, document processing, retrieval, and user experience. I work through how those pieces connect, including the tradeoffs around data quality, processing cost, access scope, and maintainability.
Turning requirements into buildable work
I use Linear to track the work, organize dependencies, and carry a feature from an idea to a defined implementation. I break larger goals into bounded tasks with clear scope, acceptance criteria, and verification steps so coding agents have a concrete definition of success.
Directing AI coding agents
I use Claude Code, Codex, and Cursor across planning, implementation, debugging, and review. The work includes supplying the right repository context, setting constraints, coordinating parallel changes, and evaluating the output. I remain responsible for the architectural decisions and for deciding whether the result meets the requirements.
Building with Fusion Coding tournaments
I use Fusion Coding tournaments to develop production-level code through competing implementations, independent evaluation, and integration. Candidates work against a shared contract; review compares their approaches, and integration brings the strongest work into a final implementation. That result still has to pass verification before release.
Verifying behavior and resolving defects
I direct testing and review across type checks, focused tests, end-to-end workflows, and browser checks. When something fails, I work from a reproducible problem, investigate the cause with the agents, and check the repair against the original requirement. I evaluate correctness, source traceability, access boundaries, and the experience a person actually uses.
Carrying the work through delivery
I manage the path from isolated branches and worktrees through integration, CI checks, deployment, and post-deployment verification. Linear tracks the work alongside code and test evidence. The lifecycle includes reviewing what shipped, documenting decisions, and feeding the lessons into the next iteration.
What I’m learning.
Retrieval quality
How to measure whether the right evidence was found, rather than judging an answer by how confident it sounds.
Operational reliability
How ingestion and parsing behave under real data volume, uneven source quality, retries, and memory limits.
AI-assisted engineering
How to give coding agents clear boundaries and verify the resulting implementation with tests and end-to-end checks.
Human review
How to make context, uncertainty, and source evidence visible without overwhelming the person using the workspace.
See the product thinking.
Explore the workspace concept and Govie’s role in it.