A public intake form that will not accept an incomplete proposal
A case study in turning a paper-and-email process into a web form whose rules come from the regulations, and whose guide cannot disagree with it
At a glance
| Situation | A government office that sells and leases state-owned assets receives unsolicited purchase and lease proposals by letter and email, often with missing documents, and checks completeness by hand |
| Approach | A public web form with a server-side completeness gate built from the office's own requirements checklist, plus a plain-language guide generated from the same rules |
| Window | 23 September to 20 October 2026 |
| Output | A working submission portal, a public guide in web, print and PDF editions, 23 automated tests, and a written design for the next phase |
| Status | A prototype on invented demo data. It has not been deployed |
The situation
Under the office's disposition guidelines, a private party can offer to buy or lease a government asset by sending an unsolicited proposal. What the proposal must contain depends on who is offering and how valuable the asset is. An individual, a sole proprietor, a partnership and a corporation each have a different list of documents, and a higher market value adds more.
In practice proposals arrived on paper or by email. Staff then checked each one against the checklist, wrote back to ask for what was missing, and waited. Every round of correspondence was time that the proposal was not being evaluated, and the people sending proposals had no clear way to know what to prepare.
The aim was to move intake online without changing the rules: take the completeness check from the end of the process to the front, and make it impossible to submit something that the office would only have to send back.
How the work was run
- Start from the checklist, not the screen. The requirements checklist was turned into code first: which fields and documents are required for each offeror category, and which extra items apply above the market-value threshold. Those rules live in one module.
- Make the gate server-side and itemised. A proposal cannot be stored as submitted unless every required field and document is present. If it is incomplete, the person gets a list of exactly what is missing, instead of a vague error.
- Give every submission a reference number, so that the sender and the office can refer to the same record.
- Write the guide from the same rules. A public guide explains what a proposal is, what to prepare, which documents apply to which offeror, the form step by step, what happens next and common questions. Its document lists, timelines and file limits are read from the same code the form enforces, so the guide and the form cannot drift apart. A print edition and a downloadable PDF are produced from the same page.
- Match the institution's look. The interface was restyled to the office's public brand.
- Test the rules at the edges. Tests cover the gate's rules for several offeror categories and for both value brackets, an incomplete submission that must be blocked with an itemised list, and a complete one that must be accepted and stored with its files. Each test runs against a fresh temporary database and upload folder, never real data.
- Design the next phase on paper, and build only the first. Phase 1 is the submission form and the gate. Phase 2 (automatic reading of uploaded documents and a staff review screen) has its database tables in place, but is deliberately unbuilt.
The design decisions that mattered
- One copy of the rules. Because the requirements live in a single module, the form, the guide and any other system that needs to judge a proposal use the same answer.
- Hard stop on incompleteness, soft flag on suspicion. The planned document-reading step will flag a submission for a person to review when the text on a document does not match the form. It will never reject automatically, because OCR is not reliable enough to safely turn away a legitimate bidder.
- A single process for the background worker. The planned reading job is designed to run as one thread inside one process polling a queue, so the deployment note says to run it that way, and says what to change first if scaling out is ever needed.
- No default secret in production. The notes require a real secret key to be set for any live run, and call the development default dev-only.
- Pull, not push. In production the portal runs in the cloud and the staff system stays on premises. The staff side fetches submissions from the portal, so the portal never reaches into the internal network.
Where it could still go wrong
- Sensitive uploads. Submissions can include bank certifications, government IDs and notarised affidavits. This is more sensitive than anything else in the project, and the notes say so plainly. Encryption at rest, per-user security and TLS are left as decisions for the agency's IT unit and are not implemented.
- No feedback to the sender. After submitting, the person sees nothing about where their proposal stands. Showing status would require the internal system to send information outward, which reverses the pull-only rule, so it was left as an open question for the agency.
- Moving data from cloud to premises. The transfer method is undecided. An export endpoint on a public application exposes personal data and would need a security review before it exists.
- Uploaded files stay in the cloud. Staff cannot yet open a submitted document from their own system.
What was left open
- The staff review screen and the document-reading checks (Phase 2).
- Buyer accounts and identity verification.
- Email or text notices, bid security and online payment.
- Independent security testing and a data-privacy assessment before any live use.
- Data-residency rules for hosting personal data and identity documents in the cloud.
Takeaways
- Put the check where the cost is. Catching an incomplete proposal at submission is cheaper for everyone than finding it weeks later.
- One source of truth for rules. When the form, the guide and the back office read the same module, a rule change is made once.
- Automation should flag, not decide. Where the evidence is unreliable, send it to a person.
- Build the first phase, design the second. Having the tables and the plan ready, without the code, kept the first release small and the choices open.
- Write down what you did not build. The list of open decisions is as useful to the agency as the working form.
About these numbers
Counts of tests and dates come from the project's repository and notes. All data in the prototype is invented. The portal has not been security tested or deployed, and nothing here describes a live service.