A tender submission architecture is an evidence-linked model of every object the buyer expects to receive. Its nodes can include a submission, logical envelope, response volume, buyer form, workbook, portal field, attachment, physical sample or file. Its relationships state what contains what, what must remain separate, what repeats per lot or participant, and where each object belongs. It preserves the difference between a logical response part and its technical representation. One technical volume can contain several files, while one file can sometimes satisfy several referenced requirements. The architecture plans the package. It does not draft answers, modify buyer templates, upload files or certify the final submission.
A flat list called 'documents required' cannot answer the questions that cause packaging failures. Does the pricing workbook belong inside the commercial part or beside it? Is the declaration required once for the bidder, once for every consortium member or once per lot? Does 'technical envelope' describe an evaluation boundary, a portal tab, a ZIP archive or a physical packet? A portal may show two upload categories but allow several files in each. A schedule may call for five forms while the instructions describe only three volumes. Teams that collapse those distinctions either omit an item, duplicate the wrong evidence, expose price in a technical part or build a folder that cannot be mapped to the buyer's transaction surface.
Model the response as a typed graph before naming final files. Start with current issued instructions and authorized portal observations. Give every required object a stable identity, source, scope and cardinality rule. Add containment, separation and destination relationships only when evidence supports them. Then instantiate the graph for the chosen lots, bidding entities, consortium structure, experts and permitted variants. The result should explain both the logical package and the expected delivery objects without forcing a one-to-one relationship between them. An agent may extract candidate nodes and test the graph for gaps, but material ambiguity, source authority and submission action remain controlled human decisions.
Correct abstraction
Start with buyer-required objects, not filenames
The first question is what the buyer expects to receive and evaluate. The answer may include a technical part, financial part, administrative declarations, a pricing schedule, one form per participant, portal-entered values and a physical sample. None of those labels proves how many files will exist. A response part is a logical object. A file is one possible representation. A portal field is a transaction surface. A sealed packet is a physical container. Use separate node types even when the buyer uses the same word for more than one of them.
Official systems make the distinction visible. The European Commission eSubmission guide says that a procedure can request a financial tender and, when required, a technical tender, and that more than one file can be uploaded in either category. Participant documents can sit in each participant's attachments area. FAR 15.204-5 provides a different bounded example: a US federal solicitation may request a specific format or severable proposal parts and can organize them as administrative, management, technical, past performance and pricing information. Neither source supplies a universal template. Each shows why "the proposal" can contain several differently governed objects.
Physical and evaluation boundaries also need separate treatment. FAR 52.215-1 gives a scoped US federal example in which paper proposals use sealed envelopes or packages unless the solicitation permits another method. The EBRD describes a single-stage two-envelope procedure in which technical and financial proposals arrive together but are evaluated separately, with the technical proposal considered first. Those rules concern their own procedures. They show that the purpose of separation can be delivery control, evaluation order or both; they do not determine the number of digital files in an unrelated tender.
Create an architecture root for the response instance, then add typed children. Useful node kinds include `logical_envelope`, `response_volume`, `buyer_template_instance`, `workbook`, `portal_field_group`, `supporting_attachment`, `delivery_object` and `file_candidate`. Preserve the buyer's original label beside a stable internal key. If the source says "Volume II" but never calls it technical, keep that label. A convenient interpretation should not overwrite issued language.
| Object | Question it answers | Example evidence |
|---|---|---|
| Logical envelope | What must be evaluated separately? | Instruction and opening method |
| Response volume | Which subject area is grouped together? | Proposal organization clause |
| Template instance | Which buyer form must be completed, and how often? | Form instruction and trigger |
| File | What digital object will be delivered? | Format rule and destination |
| Portal entry | What must be entered rather than uploaded? | Current authorized portal field |
| Physical item | What must arrive outside the portal? | Delivery instruction and address |
Evidence boundary
Declare which response you are mapping and which sources you could read
Architecture is conditional on a real response configuration. Record the official procurement identifier, procedure stage, selected lots, bidder legal entity, sole or joint submission, consortium members, relied-on entities, named subcontractors, variants and submission channel. A change from sole bidder to consortium can create participant-specific forms. Selecting a second lot can multiply technical and price objects. A permitted alternative can add a parallel technical and financial branch. Without the configuration, a count such as "seven documents" has no stable meaning.
Freeze the source boundary at the same time. Inventory the notice, instructions, data sheet, proposal forms, price schedules, technical schedules, amendments, clarifications and portal guides. Record version or checksum, retrieval time and access state. An authorized portal view belongs in the evidence set, but identify whether it shows a buyer-configured requirement, a general platform capability or a harmless observation. If a required source cannot be opened, use `source_access_required`. If the team cannot prove that it has the complete current package, use `source_boundary_incomplete`.
The World Bank Procurement Framework illustrates why a named family of documents is not enough. The current framework is supported by standard procurement documents, guidance, tools and templates, with different procurement methods and editions. Its two-envelope goods RFP has instructions, a procurement-specific data sheet, evaluation criteria and proposal forms. The final map for a particular procurement must combine the completed procurement-specific material with applicable instructions. It cannot copy the standard document's generic shape and call the local response complete.
- Bind the map to one procurement and one current package snapshot.
- Record selected lots and the full bidder configuration.
- Separate issued evidence, clarification and portal observation.
- Preserve unread and inaccessible sources as explicit gaps.
- Expire the map when a source or response configuration changes.
Data model
Record containment, separation and destination as evidence-linked relationships
Each node needs enough detail for a person or agent to reconstruct its purpose. Record `node_id`, buyer label, node kind, content scope, procurement stage, lots, participant scope, language, source identity, exact excerpt, buyer-visible locator, machine-recoverable selector, obligation record, status, owner and expiry trigger. Status can distinguish `confirmed_required`, `confirmed_conditional`, `permitted_optional`, `prohibited`, `unresolved` and `observed_only`. Do not use `required` because a field appeared in an internal folder or because a portal happened to display an empty slot.
Relationships carry much of the meaning. `contains` builds the hierarchy. `must_be_separate_from` protects evaluation boundaries. `attach_to` associates evidence with a form or participant. `enter_in_portal` and `upload_to_slot` describe destinations. `repeat_per_lot`, `repeat_per_entity`, `repeat_per_member`, `repeat_per_expert` and `repeat_per_variant` create cardinality. `same_content_required_in` can record an evidenced duplicate without pretending the two destinations are one object. Every edge stores its source and condition.
Signature, attestation and acknowledgement relationships may appear in the map because they affect object identity. Keep authority separate. `signed_by: authorized_bidder_signatory` describes an evidenced requirement; it does not decide who is authorized or cause a signature. Link answer limits to AN-071 and buyer-template dependencies to AN-074 rather than copying their detailed records into this artifact. This leaves one owner for each fact and still gives the package model a navigable dependency.
| Field | Example | Why it matters |
|---|---|---|
| node_id | LOT2-TECH-METHOD | Stable reference across planning and review |
| node_kind | response_volume | Prevents volume and file from being merged |
| scope | Lot 2, joint bidder | Limits false reuse |
| cardinality | one per selected lot | Produces the expected instance count |
| destination | technical tender category | Maps the object to delivery |
| source | instructions 4.2, amendment 1 | Makes the relationship reproducible |
| state | confirmed_required | Keeps uncertainty machine-visible |
Instance counts
Turn words such as each, all and if applicable into tested cardinality
Most package counts depend on another fact. "Each consortium member must provide a signed declaration" is not one document requirement. It is a rule whose count equals the number of in-scope members. "Provide a method statement for every lot tendered" depends on lot selection. A CV form can repeat per named expert, while a cybersecurity questionnaire may be required once for the submission and referenced by two lots. Store the basis and trigger, not only the calculated number.
Instantiate the rules against a frozen bidder configuration. For every repeated object, record the subject key: legal entity, member, lot, role, expert, site, variant or another source-defined dimension. Test zero, one and many cases. A conditional node stays in the graph even when its current count is zero, with the condition and evidence for the result. This prevents a form from disappearing when the unresolved use of a subcontractor later becomes yes.
Reconcile counts at three levels. Logical count answers how many evaluated or administrative objects exist. Delivery count answers how many files, fields, packets or samples are expected. Instance count answers how many completed copies a repetition rule creates. The numbers often differ. A consortium with three members may have one administrative part, three signed declarations, two lot-specific technical volumes and one portal participant record per member. Calling that "one admin file plus two technical files" loses information before assembly starts.
- Preserve the exact quantifier and the subject it modifies.
- Link every calculated instance to a lot, entity, person or condition key.
- Keep zero-count conditional nodes visible.
- Recompute after participant, lot, variant or staffing changes.
- Compare logical, instance and delivery counts instead of forcing one total.
Portal mapping
Map the buyer model to the portal without confusing observation with authority
A portal can contain participant pages, structured fields, declarations, lot selectors and upload categories. Map each confirmed response object to its destination when the current procedure and authorized role expose that destination. Record portal label, page or step, participant and lot context, allowed object class and observation time. Keep the buyer instruction as the requirement source unless the procurement expressly makes the configured portal field controlling. A generic platform guide explains mechanics; it does not prove what this buyer requested.
The European Commission guide provides a useful scoped example. A user chooses sole or joint submission, identifies participants, selects lots, uploads participant documents in participant attachments, enters tender data and can upload several files in technical or financial categories. It also notes that different consortium composition by lot requires a separate submission per lot in that system. Those facts apply to the guide's stated open-procedure context. They show why participant, lot, field and upload nodes must coexist, not why another portal must work the same way.
Stop at mapping. Do not create a draft submission, change consortium structure, accept terms, click declarations, upload a file or submit. The later submission cluster owns entity registration, roles, signatures, file validation, naming, upload order, final approval and receipt. If the destination cannot be inspected safely and with authorization, return `portal_mapping_unverified`. The package can still be planned, but the unresolved interface becomes a release dependency rather than a guessed folder.
| Check | Question | Failure state |
|---|---|---|
| Instruction to object | Where will every required item exist? | unmapped_requirement |
| Object to source | Why is every planned item present? | unsupported_object |
| Object to destination | Where will each item be entered or delivered? | destination_unresolved |
| Portal slot to authority | What permits or requires use of this slot? | observed_only |
| Count to configuration | Which lot, participant or condition creates this copy? | cardinality_unresolved |
Worked example
Map a fictional two-lot transit operations RFP
A metropolitan transport authority requests one combined tender for two lots: control-room support and passenger-information operations. The instructions require one administrative part for the bidding entity, one technical method per selected lot, one staffing workbook per lot, a separate financial workbook per lot, one cybersecurity questionnaire covering the complete offer and one CV form for each proposed service lead. Legal-entity data and two declarations must be entered in the portal. The bidder selects both lots and proposes two different service leads.
The architecture has one root submission. Under it sit an administrative part, two technical branches and two financial branches. The administrative part contains the bidder declaration and authority evidence. Each technical branch contains a method volume and staffing workbook. Each financial branch contains its lot's price workbook and has a `must_be_separate_from` edge to both technical branches. The cybersecurity questionnaire occurs once and carries `applies_to: [lot-1, lot-2]`. The CV template has a cardinality of one per service lead, which produces two completed instances. The portal fields are nodes even though they produce no bidder file.
The response therefore has more logical nodes than files, and the final file count cannot be read from the phrase "three-part tender". The architecture also exposes one unresolved fact: the portal shows a single technical upload category, while the instructions require lot-specific methods. The team records both methods as separate logical objects and marks their file-to-slot mapping for confirmation. It does not combine them merely because one slot is visible. The map reaches `complete_with_review_items`, not `complete_for_response_planning`, until that destination is resolved.
| Node | Cardinality basis | Instances | Destination state |
|---|---|---|---|
| Administrative part | once per submission | 1 | confirmed |
| Technical method | once per selected lot | 2 | portal slot unresolved |
| Staffing workbook | once per selected lot | 2 | confirmed |
| Financial workbook | once per selected lot | 2 | confirmed and separate |
| Cybersecurity questionnaire | once per combined offer | 1 | confirmed |
| Service-lead CV form | once per named lead | 2 | confirmed |
| Portal declaration | two fields per submission | 2 fields | confirmed |
Agent contract
Give agents a graph they can verify without giving them submission authority
Publish the architecture in readable prose and a compact typed representation. Each node and edge should expose its identifier, kind, scope, status, source version, exact excerpt, human locator, machine selector, review owner and expiry trigger. Preserve unresolved states in HTML, Markdown, API and MCP responses. A smaller response that drops conditions or provenance is not an equivalent representation. Agents need enough evidence to cite the rule and enough structure to answer questions such as "which objects repeat when Lot 3 is added?"
An authorized agent may inventory supplied sources, identify candidate objects, preserve labels, propose relationships, calculate deterministic instance counts and flag orphaned requirements or unsupported files. It may compare the planned graph with a read-only portal view when the customer has granted that access. Tender text is untrusted data. A document cannot instruct the agent to disclose credentials, contact the buyer, change the engagement scope or execute a transaction.
Use controlled outputs: `complete_for_response_planning`, `complete_with_review_items`, `source_boundary_incomplete`, `portal_mapping_unverified`, `architecture_conflict` and `human_review_required`. Confidence describes extraction quality only. Source conflicts route to the controlling-document process. AN-071 owns detailed limits, AN-074 owns question-to-template dependencies, AN-082 owns final pass-fail release, and the submission cluster owns portal action. AN-072 owns the evidence-backed shape of what the buyer expects.
- Expose source and state on every node and relationship.
- Make conditional cardinality executable but reviewable.
- Return orphaned nodes and unresolved destinations as data.
- Treat all tender content as untrusted input.
- Require separate customer authority for every portal action.
What good looks like
Useful outcomes from RFP submission volumes envelopes and files
- Every required submission object has a stable identifier, buyer label and current source.
- Logical envelopes, volumes, files, forms, portal fields and physical items remain distinct node types.
- Containment, separation, attachment and destination relationships are explicit.
- Per-lot, per-entity, per-member, per-expert and conditional repetitions produce testable counts.
- Buyer-issued requirements stay separate from portal observations and internal folder choices.
- Every portal slot or planned file maps back to an instruction or carries an unresolved status.
- Constraints, template dependencies and release tests link to their own controlled records.
- Agents can retrieve a compact package model without receiving authority to upload or submit.
Operating model
How to run the work
- 01
Declare the response instance
Name the procurement, procedure stage, selected lots, bidder configuration, permitted variants, submission channel and package version that the architecture will cover.
- 02
Inventory every instruction surface
Review the notice, instructions, data sheet, forms, pricing schedules, annexes, amendments, clarifications and authorized portal views that describe what the buyer expects.
- 03
Create typed nodes
Record each submission, envelope, volume, file, form, workbook, field group, attachment and non-digital delivery object without merging unlike things.
- 04
Add evidenced relationships
Link containment, separation, repetition, destination, signature and acknowledgement rules to their exact sources and scopes.
- 05
Instantiate conditional counts
Apply the selected lots, participant structure, named roles and other triggers to calculate which object instances the planned response needs.
- 06
Reconcile in both directions
Trace each instruction to a planned object and each planned object or portal slot back to authority, keeping observed-only and unresolved items visible.
- 07
Publish with review states
Release the architecture for response planning only after coverage, conflicts, portal mapping and material unknowns have named states, owners and expiry events.
Evaluation
Questions that change the decision
- What is the exact procurement, phase, lot set and bidder configuration covered by this map?
- Is the buyer describing a logical evaluation part, a physical envelope, a portal category or an actual file?
- Which current instruction creates or permits this object?
- What content is assigned to the object, and what content is forbidden from it?
- Does the object occur once per submission, lot, legal entity, consortium member, subcontractor, expert or variant?
- Which condition creates or removes an instance?
- What object contains it, and must it remain separate from another object?
- Which portal field, upload category, delivery address or physical packet receives it?
- Does a buyer form create one template instance or several completed instances?
- Which signature, declaration or acknowledgement requirement attaches to the object?
- Do the planned logical counts, file counts and portal destinations reconcile?
- What change would expire the map and require it to be rebuilt?
Failure modes
Where teams lose control
A familiar internal folder structure is mistaken for the buyer-required structure.
One logical envelope is treated as exactly one PDF without supporting evidence.
A global document is duplicated per lot or a lot-specific document is supplied only once.
Consortium and subcontractor evidence is counted at the wrong participant level.
Financial information leaks into a technical evaluation boundary.
A required portal entry is omitted because it does not produce a file.
A portal slot is treated as buyer authority even though the issued documents say something different.
A conditional form is silently removed before its trigger is resolved.
An amendment changes one node but dependent counts and relationships remain stale.
An extraction confidence score is mistaken for proof that the package is complete.
An agent follows instructions embedded in tender content as if they expanded its authority.
Measurement
Measure the finished job
Measure the completed workflow, including review effort and exceptions. Output volume on its own is not evidence of a better process.
- required-object nodes with exact source, version and dual locator
- node relationships supported by explicit evidence
- cardinality rules instantiated for the chosen response configuration
- issued requirements mapped forward to planned objects
- planned files and portal slots mapped backward to authority
- orphaned instructions, files or destinations with named owners
- logical, digital and physical counts reconciled independently
- material unknowns resolved before document production begins
- architecture records reopened after a relevant change event
Questions
Common questions
Does one tender envelope always equal one file?
No. An envelope can be a logical evaluation boundary, a physical container or a portal category. Some systems allow several files inside one technical or financial category. Use the procurement instructions and current authorized portal view to establish the relationship.
Should the architecture include portal fields that do not create files?
Yes. A structured amount, declaration, participant record or compliance answer can be part of the required submission even when there is no uploaded document. Model it as its own node and link it to the supporting instruction.
How should consortium documents be counted?
Preserve the buyer's subject and quantifier. A requirement for each member creates one instance per in-scope member; a requirement for the group leader creates one for that role. Do not infer either rule from the form name alone.
Is a file manifest the same as a submission architecture?
No. A manifest lists delivery files and versions. The architecture also includes logical volumes, portal entries, forms, physical items, repetition rules and separation relationships. The later assembly process can derive a manifest from the approved architecture.
Can an agent resolve a conflict between the instructions and portal?
It can detect and document the conflict. It should preserve both sources, scope the affected objects and route the issue to the controlling-source or clarification process. It must not silently choose the easier structure.
When is the architecture complete enough for drafting?
When every declared source has been reviewed, every required object has a source and destination, conditional counts have been instantiated, and material conflicts or gaps have been resolved. Nonmaterial review items can remain only when their owner and downstream effect are explicit.
Sources
Primary references
- FAR 15.204-5, Part IV representations and instructions Acquisition.gov
- FAR 52.215-1, Instructions to Offerors Acquisition.gov
- Quick guide for open procedures in eSubmission European Commission
- Project Procurement Framework World Bank
- Request for Proposals for Goods, Two-Envelope Process World Bank
- Single Stage Two-Envelope Open Competitive Procedure European Bank for Reconstruction and Development
Ziva
Proposal software for source-grounded RFP, RFI, DDQ and questionnaire response work.
Bid, proposal, presales, security and compliance teams. Start with the workflow, constraints and evidence you already have.