What it takes to build your own RFP response software
A prototype answers one question well. A bid platform qualifies tenders, shreds requirements, fills the buyer's files, builds proposals and decks, and stays up the night before a deadline.
On this page
Building your own RFP response software means building a platform for the whole bid, not a tool that answers questions. A bid team uses software to decide whether a tender is worth pursuing, pull the requirements and deadlines out of a few hundred pages, prepare clarification questions for the buyer, plan who writes what, draft and review the answers, produce the proposal document and the presentation, and return everything in the buyer's own files before the deadline. Each of those steps has its own engineering problems, and underneath them sit the parts nobody demos: document processing that survives whatever buyers send, a knowledge base that stays current, infrastructure that holds up the night before a deadline, and the security work your own InfoSec team will ask for. This guide goes through all of it, step by step, drawing on the lessons of building SEQUESTO and on what bid teams told us about the tools they built themselves. The free checklist lists every item as a line you can assign and track.
It is a long read on purpose. If you are writing a business case for an internal build, or reviewing one, most of the cost is in the sections you would not think to include.
Why the first version looks easy
The first version looks easy because a general AI model with a folder of past bids answers a single question well. Paste a tender question into a chat, attach a few company documents, and the draft is often good enough to impress a steering committee. A developer can wire the same thing into a small web app in a few days. That prototype is the reason so many organisations decide to build RFP response software themselves, and it is a poor guide to what they are signing up for.
We hear two versions of what happens next. In the first, a team writes a careful prompt, gets a strong draft, then tries the approach on a live tender. The tender is a protected Excel workbook with several hundred rows and drop-downs that point at a hidden sheet, a Word declaration full of legacy checkboxes, and a 150-page PDF with the compliance matrix at the back. The quality of the drafted text holds up. Everything around it does not. The file comes back garbled, the word counts are off, sub-questions inside numbered lists are missed, and somebody spends the evening before submission pasting answers into the buyer's file by hand.
The second version is slower. An internal AI team builds a good search over the bid library. The bid team uses it for a few months and likes it. Then the AI team is moved to the next department's project, and nobody is left to deal with the new file format a buyer sends, the model that is retired, the SharePoint site that was reorganised, or the library content that quietly went out of date. Several teams told us they had tried bid automation once before and that it failed because nobody owned the content. The tool took the blame.
Neither story means you should not build. They mean the work is mostly outside the part you can see in a demo, and it is cheaper to see all of it before the first sprint than after the first live bid.
What a bid involves, from the software's point of view
A bid is a project with a hard deadline, many contributors and a buyer who sets every rule. Software that only drafts answers covers one step of it. To judge the size of a build, start from the steps a bid team actually goes through and ask, for each one, what the software has to do.
- The tender arrives. It comes as a zip of thirty documents, a link to a procurement portal, an email with attachments, or a folder shared by a colleague. Some files are duplicates, some are in another language, some are scans. Later, addenda and clarification bulletins change parts of it.
- Someone decides whether to bid. That decision rests on the deadline, the lots, the award criteria, the mandatory requirements, the contract value and how well the opportunity fits the company. The software has to find those facts in the documents and present them so a director can say yes or no in one meeting.
- The team breaks the tender down. Requirements, questions, mandatory documents, page and word limits, formatting rules and evaluation weightings are extracted into lists the team can work from. This is what bid teams call shredding, and the result is often a compliance matrix.
- The team asks the buyer questions. Ambiguities, contradictions between documents and missing information become clarification questions, which have their own deadline, usually well before the submission date.
- The work is planned. Sections and questions go to named experts with deadlines. Bigger bids get an outline, win themes and a review schedule.
- Answers and documents are written. Questionnaire answers, the proposal narrative, the executive summary, CVs, case studies, method statements, and often a presentation for the shortlist stage.
- Everything is reviewed and approved. Several rounds, several people, sometimes legal and pricing sign-off.
- The response goes back in the buyer's format. Their workbook, filled in. Their Word form, with the right boxes ticked. Their portal, with every field completed. Plus your own documents, in your template, inside the page limit.
- After submission. The buyer sends clarification questions about your bid, invites you to present, and eventually tells you whether you won. Approved answers go back into the library for the next bid.
A tool that helps with step 6 alone leaves the bid manager doing the rest by hand, and moving data between the tool and everything else. The internal builds we hear about almost all started at step 6 and stayed there. The rest of this guide takes the steps roughly in order, then covers the knowledge base, the AI layer, the infrastructure and the platform that all of them depend on.
Getting the tender in
Before anything can be analysed, the tender has to arrive in the software in one piece, and that is less trivial than an upload button suggests. A public tender pack is often a zip with thirty or forty files: the main document, technical annexes, the questionnaire workbook, pricing schedules, the draft contract, forms to sign, sometimes a zip inside the zip. Private RFPs come as email attachments, as links to a data room, or through a procurement portal that expects you to log in and download each file. Bid teams told us that finding out which version of a document is current often means digging through their inbox.
The software has to unpack nested archives safely, recognise duplicates (the same annex sent twice under two names), keep the buyer's files untouched as the record of what was received, and attach every later document to the same bid. Folder conventions matter. One team we spoke with never edits a buyer document and moves superseded versions into an archive folder, so v0.2 never gets mistaken for v0.3. Your software either respects that kind of rule or fights it.
Expect the pack to mix languages, with the main document in one language and annexes in another, and to include scanned pages, password-protected files and the occasional format nobody has opened in years. Each of those needs a defined outcome: processed, processed with a warning, or refused with a reason the bid manager can act on. A file that silently fails to process is worse than one that is refused, because the bid manager assumes its content has been read.
Understanding the tender: summary and key facts
The first thing a bid team wants from a new tender is a short, reliable answer to "what is this and when is it due". Pulling that out of a few hundred pages sounds like a natural job for a language model, and mostly it is. The difficulty is that the facts that matter are few, precise and unforgiving.
Take dates. A tender has a submission deadline, a deadline for clarification questions that is usually much earlier, sometimes a site visit, a date for presentations, a validity period for the offer and an expected award date. Bid teams told us of summaries that put the clarification deadline in the wrong month, which is the kind of error that costs a bid. Dates come with time zones and with phrases like "no later than 12:00 noon local time", and the software has to keep that precision instead of rounding it to a calendar day. Store dates as dates, check that they parse, and refuse to fill a deadline field with a guess. A single malformed date stored in the wrong format is enough to break every report that reads it.
Money is the next trap. A contract value written as "1.234" in a Belgian tender means one thousand two hundred and thirty-four, and parsed with English conventions it becomes one point two three four, a silent thousand-fold error. A value in dollars placed into a field that assumes euros becomes the same number of euros. Ranges, per-year figures and maximum framework values all need to be kept as what they are. When a document does not state a value clearly, the field should stay empty and say so, with a link to where the software looked.
Lots add structure that a flat summary loses. Requirements, financial thresholds and award criteria can differ by lot, and a summary that merges them, for example by presenting one lot's turnover requirement as the requirement for the whole tender, misleads the decision. Award criteria and their weightings need to come out intact, with sub-criteria under the criterion they belong to, because they drive both the bid decision and how the response is written. Getting the grouping right is genuinely ambiguous: some tenders weight sub-criteria separately, others score them as one, and the extraction rules have to handle both without double-counting.
The rest of the summary is the practical detail that otherwise lives in a bid manager's notebook: how to submit (portal, email, physical copies, password-protected files), the mandatory documents and forms, page and word limits, formatting rules, language requirements, contract duration and renewal options, payment terms, liabilities, insurance levels and the certificates the buyer requires. Bid teams also asked us for different summaries for different readers. Legal wants the liability and termination clauses, the product team wants the scope, the director wants the opportunity in a paragraph. They also wanted the same template on every bid, so summaries can be compared and reported on across the year.
Every fact in a summary needs a source a reviewer can click: the file, the page, the passage. Without that, the bid manager has to check every line by hand, and the summary saves nothing.
Qualification and the bid or no-bid decision
Deciding which tenders to pursue is where a bid team's time is won or lost, and qualification support is one of the first things teams ask for once answering works. It is also two different jobs that look like one.
The first job is reading the tender: answering a fixed set of questions about it from the documents. What is the budget, what are the selection and award criteria and their points, which certificates are mandatory, what are the liabilities, the service levels, the payment and delivery terms. This is extraction with citations, and everything said above about facts applies.
The second job is judging fit: a scored self-assessment of how well the opportunity suits the company. Do we know the buyer, do we know the competition, is the budget known, are we registered on the portal, do we have the references they ask for, is there a showstopper in the contract. Every company has its own criteria, and the teams we speak with want to load their own list rather than accept a generic one. One team brought a long scoring prompt they had refined over many bids. Others want deal context the tender does not contain: the account manager, the likely revenue, the buyer's financial health, the competitors who bid last time.
Users rarely care about the distinction, and separate labels for go/no-go, bid/no-bid and qualification confuse them, so it pays to design them as one module from the start. Changing your mind later is expensive in a live product: every existing bid has to keep its old qualification data, and new modules have to be added to bids that already exist.
The scoring itself needs a proper model. Each criterion has options, each option carries points, some options are red flags that override the total, and some criteria allow several options at once whose points add up. The model chooses options, and its choice has to be matched back to your option list exactly. If the model is asked to answer in French and translates "Yes" into "Oui", the score stops working, so option labels must never be translated even when the explanation is. When nothing matches, the criterion must be marked as unanswered, not given a default.
Qualification reports are read by directors and archived, so they need to export cleanly to Word and Excel, and the answers have to stay in step with what users see on screen. Answers written in the background must appear on screens that are already open, and an answer and its sources must always be written together, or a re-run can leave old sources next to a blank field, which looks like evidence for nothing.
Not every team wants this. Some told us they decide at a glance, or that qualification happens in a meeting and will stay there. Others want the result to feed the next steps: the go decision creates a bid plan with dates back from the deadline, and the scores and red flags reappear in the executive summary. Decide which camp your bid team is in before you build a scoring engine.
Requirements and the compliance matrix
Shredding a tender into its requirements is the step bid teams describe as the most tedious and the most dangerous to get wrong. A missed mandatory requirement can disqualify a bid. Software that extracts requirements has to be held to a standard of completeness that ordinary summarisation never is.
Requirements are spread across documents. The main tender document states some, the technical annex states others, the compliance matrix the buyer supplies repeats a subset in a different order and wording, and the draft contract hides a few more. One team told us their tool extracted the Excel matrix and the annexes and ignored the main document altogether. Another had a very long list of requirements spread across several files. Their extraction stopped early, asked whether to continue, and then skipped the rest of the document. Both failures share a cause: nothing checked the result against the documents.
Long documents have to be split into pieces the model can handle, and requirements that cross the boundary between two pieces are lost or found twice. Overlap fixes the first problem and creates more of the second, so de-duplication becomes part of the pipeline. It has to work on meaning as well as text, because the same requirement appears in the main document and in the matrix with different wording. Extraction should also run a second, independent check on what it found, with a confidence threshold, so invented or paraphrased requirements are caught before a reviewer sees them.
Layout breaks extraction in ways that are hard to predict. Tables read across the page instead of down the columns. A requirement that starts at the bottom of one page and continues in a table on the next. Numbering pasted from older tenders, running 1, then bullets, then 1.1, then more bullets, where sub-requirements are the first thing lost. Running headers, footers and watermarks that turn into fake requirements. Response options ("Yes / No / Partial") that end up inside the requirement text. Each of these came up in calls with bid teams, and none of them is handled by a general-purpose PDF library.
When the requirements live in a spreadsheet, do not let the model retype them. Asked to turn a requirements workbook into a list, a model will drop rows without any warning, and converting the sheet to text first loses rows as well. The reliable approach is to read every row from the workbook in code and use the model only to decide which column means what. Count rows independently of the extraction and make the counts reconcile: rows found must equal items created plus rows skipped plus errors. If the plan points at an empty column, "0 found, 0 created" must not look like success.
Every extracted requirement needs a link back to its exact place in the source, highlighted, so a reviewer can check it in seconds. It gets difficult once text has been normalised, accents removed or table cells interleaved, and it breaks completely if extraction translates the text, because translated text can no longer be found in the original. Extract in the document's own language and translate afterwards.
Bid teams do not agree on what a requirement is, as opposed to a question, an award criterion, an exclusion ground or a contractual risk. Each category needs a written definition that also says what it is not, or the same sentence lands in three lists. Users will correct the categories, and those corrections are useful: items they validate or delete can be fed back to refine each definition for that company.
The compliance matrix itself is a deliverable with a format the buyer often dictates: requirement, reference, compliant yes or no or partial, a comment, a pointer to where the response addresses it. "Compliant" has to mean that the response really addresses the requirement. An AI agent will happily declare a proposal complete while whole sections are missing, if a requirement mentioned somewhere counts as covered. Coverage has to be tracked per requirement, with statuses such as compliant, partially compliant, not addressed and needs clarification from the buyer, and "complete" is allowed only when every requirement is either compliant or genuinely not applicable. That check is expensive on long documents, since each requirement has to be checked against the whole response, so it needs batching and a plan for documents too large to check in one go. A false "complete" is always worse than a false "incomplete".
Finally, not every requirement matters equally to the team. On a framework renewal, extraction can find hundreds of requirements when only a handful differ from what the company always does. Give the team a way to mark the standard ones and focus on the rest.
Clarification questions for the buyer
Every tender has a window for questions to the buyer, and good bid teams use it. The software's job is to help find what needs asking, before that window closes.
There are two kinds of question. Some come from mistakes in the buyer's paperwork: two documents that give different deadlines, a different contact person in the annex and the main document, a pricing schedule that does not match the lot structure. Others come from genuine ambiguity or risk: a service level that is not defined, a liability clause that is unworkable for the type of contract, a requirement that excludes your solution without saying so. Bid teams told us that clarifications are also strategic: a well-placed question can push back on an unreasonable term or shape the buyer's thinking, and asking shows the buyer you read everything.
Finding contradictions across twenty documents and a few hundred pages is a real test for an AI system. It needs the same extraction discipline as requirements, then a comparison step that looks for conflicts between documents rather than within one. Before a question goes on the list, the software should check whether the answer is already somewhere else in the pack, because asking a question the documents already answer tells the buyer the opposite of what you intended. Teams told us they miss real issues and ask unnecessary questions in roughly equal measure when they do this by hand.
The output is usually a clarification register, with each question, the reference it relates to, the reason, the date it was sent and the buyer's answer, plus a document in the buyer's required format to send. Clarifications come in rounds. The buyer's answers, often published to all bidders in a Q&A bulletin, can change the specification, add documents or change answers you have already written, and the software has to bring those changes back into the bid.
Addenda, new versions and Q&A bulletins
Tenders change after they are published. Buyers issue addenda, corrected annexes, extended deadlines and bulletins answering every bidder's questions. Some reissue the whole tender. Each change can invalidate part of the work already done, and bid teams want to know exactly which part.
That requires comparing versions in a way that understands tenders. A generic document comparison reports every changed comma, which is noise. What the bid team needs is a list of changed obligations: requirements added, removed or altered, dates moved, weightings changed, questions reworded. It also needs a link from each change to the answers it affects. Teams that bid repeatedly for the same buyer want the same thing across years, comparing this year's tender with last year's to see what changed and reuse what did not.
Two engineering details make this workable. Extraction has to be repeatable, so that running it on version 2 recognises the requirements it already found in version 1 instead of creating duplicates, and the identifiers it uses have to survive changes to your own software, not only to the documents. Change how items are keyed in a software update, and the next re-run duplicates everything it found before. And comparing two long documents runs into the same size limits as everything else, so large comparisons need to be split and their partial results kept, rather than failing at the last step. Bid teams told us of comparisons that hit limits on exactly the large reissued tenders where they mattered most.
The bid workflow and the people in it
Drafting is one part of a bid manager's day. The rest is chasing: who has the section on data protection, has legal seen the liability answer, which CV is the current one, why does the pricing tab still say "TBC" two days before the deadline. A tool that drafts and does nothing else leaves that day unchanged, and the teams that built search or drafting first told us the workflow was the part still missing a year later.
The basics are assignment and status. Questions and sections go to named people, with deadlines, and each person sees their own list rather than the whole bid. Every answer and section has a state, such as drafted, in review, approved, and the bid manager sees the whole bid's state at a glance. Reminders go out before deadlines slip and escalate when they do. Comments and mentions reach people in the channel they actually use, whether that is Teams, Slack or email, once, and not ten times for ten edits. Digests are not a nice-to-have; an expert who gets forty notifications a day turns them all off.
Bids are written by several people at the same time, and now by the AI as well. Real-time co-editing, where two people and an agent can work in the same document without overwriting each other, is a solved problem in the sense that the techniques are known, and an unsolved one in the sense that every team that builds it spends months on the edge cases: offline edits, very large documents, an agent writing a thousand words into a section someone is reading, and the moment two edits arrive for the same sentence. Bid teams also finish documents in Word, Excel and PowerPoint, and the buyer requires Office files, so editing in the browser has to keep validations, styles and formats intact, which usually means running a document server for in-browser Office editing alongside your own editor.
Version history is expected. Reviewers want to see what changed since their last pass, and bid managers want to restore a section to yesterday's version when a late edit goes wrong. The bid itself carries data the team wants to track and filter on, such as deadline, value, lots, status, owner, sector and outcome, and every organisation wants different fields. Fixed fields push teams back to a spreadsheet next to the tool. Leadership will ask for win rates by number of bids and by value, time spent per bid, and which content wins, so the data has to be captured from day one; it cannot be reconstructed later.
The most underestimated users are the occasional ones. Subject-matter experts in engineering, legal, finance or HR open a bid tool a few times a year. If answering their three questions is harder than typing into the general AI chat they already use, they will use that instead, and the bid team will copy their answers in by hand. Build for the expert who logs in twice a year, not only for the bid team who live in the tool.
Reading the buyer's questionnaires
Questionnaires are where most bid software is judged, because they are the most repetitive work and the easiest to measure. They are also where the most shortcuts fail, because every buyer builds their form differently and your test files are never as strange as the ones that arrive on a Friday afternoon. Plan for Excel, Word, PDF and PowerPoint, in every language you bid in.
Excel workbooks
A questionnaire that looks like a simple grid to a person is, inside the file, a set of conventions that differ by the software that produced it and the version of Excel that last saved it. The Office Open XML standard describes the format; buyers' templates explore every corner of it.
Drop-down lists are the first surprise. A drop-down whose options sit on another sheet is written by Excel 2010 and later in an extension block of the file, separate from the classic validation block that most libraries read. A reader that checks only the classic block finds no options at all on many real questionnaires. Buyers also like to keep option lists on hidden helper sheets behind named ranges, and named ranges come in more forms than you expect: plain lists of values, whole columns, unions of several areas, and names that are only valid on one sheet. A list defined as a whole column covers more than a million cells. Read it one cell at a time and a single workbook takes minutes or runs the worker out of memory, so the scan has to stop at the last used row.
Finding where the answers go is the second problem. On a protected sheet it is fairly easy, because the cells the buyer wants filled are the unlocked ones. Most questionnaires are not protected, though, and then you need several signals together: a validation on the cell, a header that means "response", a border, a fill colour, an empty cell next to a filled one. None of them is reliable alone. One sheet can also hold several tables stacked on top of each other, each with its own header row and answer column, and a reader that finds only the first header leaves whole blocks unanswered while reporting success.
Headers are in the buyer's language. "Response", "Antwort", "Commentaire du fournisseur", "Odpowiedź", "Svar": an English list of header words turns a French or Polish grid into a sheet with no form at all. Some headers mention answers without being the answer column. "Answer guidance" describes the question; "Expected answer" can be the buyer's model answer. Other headers carry rules that no drop-down enforces. A column headed "Compliance (FC/PC/NC)" or "Score 1 to 5" expects a code, and a paragraph of prose in that column can cost you the marks for the row.
The rest of the list is long, and every item on it has turned up in a real tender:
- Banners merged across several columns create phantom answer fields, while two merged boxes side by side can fuse two answers into one.
- Answers written into hidden rows or columns are invisible to the evaluator, so the software has to refuse to place them and say so.
- Row references such as "1.10" or "3.2.1" look like section headings to a naive parser, which then treats every row below as part of a heading.
- The same question text appears on several tabs with different expected answers, so questions must be identified by sheet and row, never by their wording.
- Some workbooks show or hide questions based on earlier answers, through formulas or conditional formatting, and some grow longer once the first answers are in.
- Placeholder text such as "[Insert details]" sits in the answer cell and must be recognised as empty.
- Columns the buyer has already filled, such as weighting or reference numbers, must stay read-only.
- Files produced by software other than Excel write the same structures with different XML prefixes. A strict reader opens them and finds zero sheets.
- Legacy .xls files, macro-enabled .xlsm files and CSV exports still arrive in tender packs, and converting them to .xlsx can lose the drop-downs you needed.
- Very large sheets, with tens of thousands of rows of product lines or price items, need streaming rather than loading the whole file into memory.
Bid teams describe the same thing from their side: old workbooks locked in odd ways, drop-down values that change from one row to the next, character limits on protected cells, and the instruction to re-protect the sheet before sending it back.
Word forms
Word forms take input in at least four ways, and buyers mix them in one document. Legacy form fields, the text boxes, checkboxes and drop-downs from older versions of Word, are still standard in public-sector forms and in German and Austrian self-declarations. Newer forms use content controls, including checkboxes that have no stored state at all until someone ticks them. Many forms use typed box symbols instead, sometimes from symbol fonts such as Wingdings, sometimes written as encoded characters. And a great many are simply tables with an empty column to fill.
Each kind has a trap. A box symbol inside a sentence ("mark the box where applicable") is wording, while a row of boxes after "yes" and "no" is a question, and the parser has to tell them apart. Writing an answer that begins with a tick symbol can create a new checkbox in the eyes of your own parser and shift the numbering of every later field, so the next answers tick the wrong boxes. Tracked changes nest formatting in ways that break simple text extraction. Text boxes are stored twice, once for current Word and once as a fallback, and writing to the copy Word does not display leaves the box looking empty. Narrow spacer columns in tables make answers wrap one character per line. Some blank forms arrive as .dotx templates that open as a new untitled copy every time. Some declarations ask you to strike through the statements that do not apply, which means your software has to apply strike-through, not only text.
PDF forms and scans
PDFs come in three kinds, and you need a route for each. Fillable forms are the friendly case, until you meet their fonts: the standard fonts in PDF forms cover a limited character set, so a less-than-or-equal sign, a Polish name or a curly quote can make the save fail or turn into question marks. Different viewers also draw checkboxes from different stored values, so a box that looks ticked in one viewer looks empty in another.
Flat forms are more common than buyers realise. Somebody printed the form to PDF, and there are no fields left. The software has to find the boxes, lines and table cells on the page, work out which belong to which question, and place each answer on top of the page at the right position and size, inside the box. Scans are flatter still: a scanned page has no text at all until OCR gives it some, and OCR quality varies from page to page. On top of that, buyers' PDFs are often slightly malformed, produced by old or unusual software, and the parser has to tolerate that rather than fail the whole document.
PowerPoint and other formats
PowerPoint arrives as an input more often than people expect: briefing decks, presentation templates the buyer wants you to use, and requirement tables pasted into slides. Hidden slides need a decision (read them or not), and slides need to be read one at a time so that a citation can point at slide 14 rather than "the deck". We come back to PowerPoint as an output later, which is a much bigger topic.
Portals
Some questionnaires never arrive as a file. Procurement portals such as SAP Ariba, Coupa or Jaggaer often let you export the questions to Excel, answer offline and import, or paste each answer back field by field. Some no longer offer an export. Some reveal new questions as you answer the first ones, so ten questions become thirty. Some log you out after a short idle time with your unsaved answers. Decide early which portals you will support and how: export and import, assisted copy and paste, or manual entry. It is a scope decision with real cost, not a detail to settle later.
Writing answers back without breaking the file
Buyers expect their own file back, filled in, looking exactly as they sent it. A tidy new document in your format is not the same thing, and some buyers reject it outright. This is where internal tools most often lose the bid team's trust, because a broken file is usually discovered by the buyer, not by you.
The safest rule we have found is to edit only the cells, fields and paragraphs that hold answers, and to leave every other byte of the file alone. Most spreadsheet libraries do the opposite: they open the whole workbook into memory and write a new one out, and on the way they rewrite table definitions, drop filters, reorder parts or lose the extension block where the drop-downs live. Excel then opens the file with a message offering to repair it. Repair does real damage. Excel deletes what it cannot read, sometimes whole blocks of rows, and reports it in a dialog the evaluator clicks away. So check row counts and structure before saving, refuse to save a file that lost anything, and open the result again to confirm every value landed where it was meant to. A visual check by a model is slow and unreliable for this. Re-reading the file is cheap and exact.
Data types matter. A score written as text breaks the buyer's formulas, and a product code written as a number loses its leading zeros. A single Excel cell holds at most 32,767 characters, and writing more corrupts the file. One invisible control character, pasted from an old document, can make a workbook impossible to open. Formulas that depend on your answers keep showing their old cached results until something recalculates them, so totals can look wrong when the buyer opens the file unless you tell Excel to recalculate on open. Sheets the buyer protected must be protected again, with the same settings, before the file goes back.
Answers have to fit the form's own options exactly. When the model writes "3.5 out of 5" and the drop-down offers whole numbers, the software must not pick "3" on its behalf. When the model writes "No problem, yes we do", it must not match "No". Bulk fills need their own check: a fill can copy one summary paragraph into every row of a sheet, leave two other tabs empty, and still report success. Count answered, skipped and failed items per tab, and make them add up.
Word has versions of the same problems. Writing into an empty paragraph the wrong way produces a file Word calls unreadable. A table cell with several paragraphs can collapse into one line after a conversion, and that structure is gone for good. Styles drift a few pages into a generated document, fonts that are not installed change the layout and the page count, which matters when the buyer sets a page limit. File names need care too: characters that are fine on one operating system break a download on another, and two exported files with the same name overwrite each other in a zip.
One bid consultant told us they had given up on round-tripping Word altogether. They draft in plain text and apply a styled template at the end, because the formatting was lost too often. That works for documents you own. It does not work for the buyer's form.
Proposal documents in your own template
Most bids include documents the buyer does not supply: the technical proposal, the method statement, the executive summary, the management plan. These go out in your company's own Word template, with your styles, cover page, headers and branding, and bid teams are clear that anything else looks unfinished. Several told us that a plain Word file, however good the text, was not acceptable as a final draft. Producing a branded document that a designer would sign off is one of the larger engineering jobs in this whole list, and one that prototypes skip entirely.
There are two ways to use a template, and the software has to know which one the user means. The first treats the template as a design reference: take its page size, margins, fonts, heading styles, colours, cover and footer, and build a fresh document with the new content. The second fills the template as it stands: keep every page, replace the placeholder text, leave the rest untouched. "Use our template" can mean either, and the software has to ask or choose sensibly, because filling a template as it stands carries over everything in it, including old body text, comments and sometimes another client's name.
That last point deserves a rule of its own. A header that says "Proposal for" followed by the client of the last bid, repeated on every page, is the kind of mistake a buyer notices immediately. Header, footer and cover text must come from the current bid or from the user, never from whatever the template happened to contain. The same goes for sample images in templates, which are often photos from another client's case study.
Word's file format makes the fill-in route treacherous. Numbered lists need their own numbering definitions, or every list in the document continues the numbering of the first one. Tracked changes inside a paragraph you rewrite have to be handled, not discarded. Section breaks hold page orientation and headers, and deleting one by accident changes the layout of everything after it. Fields, footnotes, comments and symbol characters each need to survive a rewrite. A template that contains text which looks like your own placeholder syntax can send a naive filler into an endless loop. None of them shows up on a simple test document, and every one of them shows up eventually on a real template.
Tables are where generated documents go wrong most visibly. A question-and-answer table in the source has to stay a table in the output, with the same columns; given the option, an AI layout step will sometimes turn a table into stacked paragraphs, and an AI reviewer will sometimes accept it. Tables also break page limits, size limits and layout checks in ways prose does not, because a table that looks small on screen can carry a lot of text.
Checking the result needs a rendered view. A document can be valid XML and still look wrong: a heading stranded at the bottom of a page, a table split across two pages in an unreadable way, an image that overflows the margin. Checking layout means looking at rendered pages, and any automatic repair should be limited to spacing and flow, never content. Separately from any visual review, the output has to be compared with the source to confirm that wording, order, amounts and footnotes survived, and a repair attempt that makes things worse must never replace a better version. If some passages cannot be placed, they are appended at the end and reported, because a document that says it contains everything and does not is worse than one that says what is missing.
Page limits connect all of this to the bid rules. Buyers set page limits, sometimes per section, and fonts, line spacing and margins can be prescribed too. Bid teams told us that models are bad at hitting a page count, so they convert page limits into word counts and hope. The software can do better by measuring the rendered document, which requires the fonts the template uses to be installed wherever the rendering happens. A different fallback font changes line breaks, and line breaks change page counts.
Executive summaries
The executive summary is the section decision makers read, often with the pricing and the references and nothing else. Bid teams told us they want it to start from the buyer's problem rather than the bidder's history, to reuse the win themes and the qualification findings, and to stay in line with the rest of the response. They also told us what goes wrong. Asked for an executive summary, general AI tools write a textbook explanation of the service instead of the company's own proposal, and, worse, they produce precise figures that sound right. One team described a draft that promised a specific service level with no source behind it, and stated performance targets that their company deliberately never commits to in tenders. In an executive summary those errors are read by the people who decide. Everything said earlier about grounding applies here with more force, and so does the bid team's own library of approved summary blocks, which many teams already keep per type of client.
Legal review and red flags
Tenders carry a draft contract, and someone has to read it. Legal teams want the buyer's terms compared with the company's own positions: liability caps, indemnities, intellectual property, termination, service credits, data protection, insurance, payment terms. They want the deviations flagged and a short list of showstoppers, early enough to raise them as clarification questions. Public frameworks can run to many schedules, some of them a hundred pages long, and every one has to be read.
Two requirements make this harder than summarising. First, what counts as a red flag differs by company and changes as the legal team corrects the software, so the definition has to learn from the items they confirm and the ones they delete. Second, legal teams want their changes in a form they recognise. In one call, the request was for every proposed change to the contract to appear as a tracked change with a comment explaining why. Writing tracked changes into Word correctly, through tables and hyperlinks, without nesting revisions inside revisions, is precise work.
There is a quieter legal risk in the answers themselves. A security or compliance answer drafted from a policy document can commit the company to operate in a way it does not. That risk sits with the review workflow, but the software can help by flagging answers that make commitments, such as service levels, response times, certifications and guarantees, for a named reviewer.
CVs, case studies and references
Many tenders ask for CVs of the proposed team, in the buyer's format or your own, with a page limit per CV. Teams told us they cannot rebuild a CV for every bid and want the current one, trimmed to what this buyer asks for, in the right layout. Case studies and references are similar: the software has to find the past projects that best match this buyer's sector, size, region and requirements, check that the reference is still allowed to be named, and present it in the required form. Both depend on the library holding structured, current records rather than a folder of old Word files, which brings us back to content ownership.
Pricing and the commercial response
The commercial response is usually a separate workbook with many tabs, a bill of quantities or a rate card, and specifications that live in another annex. Quality and price are typically weighted separately, and the commercial team often works on pricing in parallel with the bid team. Most of this stays with the commercial team and their own tools, and should. The bid software still has to handle three things. It must fill the buyer's pricing template without damaging it, which is the Excel problem from earlier with more formulas. It must never reuse a price from an old bid as if it were current, so prices in the library need to be marked as indicative or approved, and dated. And numbers must survive: a European thousands separator, a currency symbol in the wrong place or a negative written in brackets can change a figure by a factor of a thousand or flip its sign without anyone noticing. Each one is easy to miss in testing.
Presentations and PowerPoint decks
Shortlisted bidders are often invited to present, and many bids include a deck from the start: a solution overview, a management presentation, a defence of the offer. Bid teams want the software to turn the written response into slides in the company's own PowerPoint template, and in our experience this is the hardest generation task in the whole list.
The easy version takes the content, asks a model for a title and five bullets per slide, and places them on the template's title-and-content layout. It runs in a demo. Bid teams who tried it described the result as unusable: walls of bullet points on wide slides, nothing like the decks their designers produce, and they went back to building decks by hand to keep their branding.
Why it is hard
A PowerPoint template is a master, a set of layouts and often dozens of example slides, each a page of positioned shapes with their own fonts, sizes, colours and text limits. The model cannot see any of that unless you describe it, and if you describe it badly it works blind. Map content to shapes by their position in a list and a banner's text lands in the body box. Give the model no idea how much text each shape holds and it writes paragraphs into boxes designed for a three-word statistic. Let it plan slide by slide and a template with dozens of carefully designed slide types produces decks that use a handful of them, with no cover or closing slide. And if nothing looks at the finished slides, blank decorations and internal drafting notes go out.
Round trips through online presentation services cause damage of their own: template font sizes reset to a default, so text grows and overflows; native charts flattened into pictures; special characters escaped twice; table frames with stale sizes. If you are planning to generate decks through Google Slides or a similar API, test a round trip of your own template first.
Making text fit
Text fit has to be measured in code, from the geometry of each shape and the font size that actually applies to it, and the font size is surprisingly hard to find. It can be set on the run, the paragraph, the shape, a list style, the layout or the master, and it is inherited down that chain. Get the inheritance wrong and every text budget in the deck is off by the same factor at once.
Characters are not the only limit. Seventeen one-line bullets can fit the character budget of a box that has room for eleven lines, so the number of paragraphs and lines needs a limit too. Boxes set not to wrap clip their text instead of flowing it, and multi-column boxes need checking column by column. Speech bubbles, callouts and other non-rectangular shapes hold less text than their bounding box suggests. When content still does not fit, the fallback is a bounded reduction of the font size, recalculated every time the slide is assembled, and never an overflow onto the slide.
Shortening text to fit fails in a predictable way: models abbreviate. "Cross-border coord." is shorter and unreadable. The shortening step has to be told not to abbreviate, and below a certain budget it works better to rewrite from scratch than to trim. The opposite problem is real too. A rich slide with too little content looks unfinished, and the temptation is to pad it with invented prose. Each slide needs a target fill, and the rule that the software never pads with content that is not in the source.
Tables, charts and pictures
Tables on slides are a failure class of their own. New rows cloned from the template copy the template's tall sample row, and the table marches off the bottom of the slide. A template table with fewer columns than the content drops a column, and it is always the column that matters, such as the fees. Narrow columns wrap a word over several lines. Merged cells break the reconciliation between template and content. Merging two thin slides into one can lose a table altogether, so merges involving tables need refusing, and any table text that does not arrive in the output has to block the deck rather than produce a warning.
Charts, SmartArt diagrams and embedded objects are invisible to text extraction. If they are not modelled explicitly, a slide reused from an old deck ships with the old deck's chart. Timeline and Gantt slides show the other side of the same problem: when the model relabels a timeline, the bars stay where they were, because their positions are coordinates and not text. The answer is to never let the model do coordinate arithmetic. It edits the content, and code redraws the bars, card grids, team walls and number tiles from that content.
Templates carry placeholder pictures baked into slides, "insert photo here" images that no text check can see. They need detecting during template analysis, so they can be replaced or removed. Images you add need their proportions kept, their size limited and their source checked against the user's permissions.
Reusing slides from past decks
Bid teams have years of good slides and want to reuse them, so slide reuse becomes a subsystem. Past decks have to be split into slides and indexed one slide at a time. A slide picked for reuse has to be copied into the new deck with its layout, master, theme, fonts and media, rescaled if the old deck is 4:3 and the new one 16:9, and its table styles carried over. Masters no slide uses any more should be removed, or files bloat with every reuse.
A reused slide also carries its old content. Changing the client name in the title is the easy part; a general rewrite step will leave most of a timeline's labels from the old project in place. Adapting a slide well needs a dedicated step that reads the rendered slide, reasons about what every element means, and touches every element. When a user says "use this slide", that choice must be respected by every later step, including the de-duplication and automatic repair loops that would otherwise swap it out.
Checking the deck
A deck needs two kinds of check, and they catch different problems. The first is the file itself. Preview renderers display files that desktop PowerPoint refuses to open. A deck can render perfectly in a preview and still refuse to open in PowerPoint because of an invisible character copied from a source deck, an unescaped font name, an image registered twice as "JPG" and "jpg", duplicate shape identifiers in a copied group, a broken internal link, or a namespace prefix PowerPoint did not expect. Validate the package with the same strictness PowerPoint applies.
The second check is visual: render the slides, inspect them, fix what can be fixed automatically, and report the rest. Two rules are worth stating. Slides that did not change keep their previous verdict, or repeated inspections contradict themselves. And if the rendering service stalls, the finished deck is delivered with a note that it was not visually checked, instead of being thrown away.
Internal notes are a deck-specific leak. Drafting notes, "assumptions below", reminders to check a figure: in a document they are embarrassing, on a slide shown to a buyer they are worse. Internal notes need a way to be marked and stripped before output, a check for self-referential phrasing, and a final copy-edit pass over the whole deck. Speaker notes are the useful counterpart: detail that does not fit on a slide goes into the notes, provided the template has a notes layout, and edits must not wipe them.
Users want to approve an outline before slides are built, and to fix one slide without regenerating the deck. Regenerating a whole deck to change one slide takes long enough that people give up; fixing one slide should take seconds. That needs stable slide identifiers, and a refusal to apply a fix when the user has reordered the deck since, so the wrong slide is never changed. Files here are large and heavy to process. Templates arrive with embedded videos and hundreds of megabytes of images, so video and audio have to be stripped, photos downscaled and overall sizes capped before processing starts. Memory, not processing power, is what limits how many decks a server can build at once.
Finally, a deck generator needs evaluations of its own: a fixed set of templates and content, automatic checks for fit, overflow and leftover placeholder text, and a visual score with a floor per slide, because an average score hides the one broken slide a buyer will remember. Every new template you meet should become a test case, so improvements for one template do not break another.
After submission
The bid is not over when it is submitted, and the software's job is not either. Buyers send clarification questions about your response, sometimes with a short deadline, and the answers must stay consistent with what you submitted. That means the submitted version has to be frozen and findable, separate from the working drafts that kept changing afterwards. Shortlisted bidders present, which brings the deck back. Some procurements include a best-and-final-offer round, which reopens the pricing and parts of the response.
Then the result arrives, often months later, and this is where the library is supposed to improve. Bid teams told us they want only answers that scored well to go back into the library, with the buyer's feedback attached to the specific answer it was about. In practice feedback arrives as a letter or a debrief call, is scattered across inboxes, and post-mortems are rare. If the software captures the outcome, the scores and the feedback per section, and links them to the answers and the content they came from, the next bid can prefer content that won. Because of the delay between submission and award, it also needs a way to add submitted answers to the library before the result is known, marked as unproven, and to promote or retire them once it is.
Win rates, time spent per bid, which content is reused and which sections lose marks are the reports leadership asks for, and they only exist if the data was captured along the way.
The knowledge base
The knowledge base decides the quality of every answer, every qualification report and every slide, and it is the part that decays fastest. It is also where internal projects most often stall: a good search gets built, and the work of keeping it current, permissioned and trustworthy is never staffed.
Deciding what the AI may read
The first decision is not technical. Connecting every intranet folder to the AI feels generous, and it brings in drafts, superseded policies, other clients' pricing and the 2014 version of your security policy. Teams that tried it told us they ended up wanting a curated library instead, with a clear rule for what goes in and who approves it, alongside read access to the working folders where current material lives. Both have a place, and the software has to know which is which, because an answer from an approved library entry and an answer from a draft found in a project folder deserve different levels of trust. How to build an auditable answer library covers the content side.
Getting documents in
Every converter loses something. Table structure, reading order, rows of a spreadsheet, the options of a drop-down, the text in a diagram. Measure what yours loses on your own documents before you trust it. Spreadsheets are the classic case: converted to text, they can lose rows without any error, which is why rows are best read from the original file.
OCR and document conversion are usually external services or heavy processes you run yourself, and both have limits. An "overloaded" response is a reason to wait and retry, not a failed file. Interactive uploads need their own capacity, so a colleague's import of ten thousand archived bids does not leave everyone else waiting for hours to read a two-page addendum.
Images often carry the answer: architecture diagrams, certificates, org charts, screenshots of a product. They need real descriptions to be searchable, generated by a model that looks at the picture, and a file name is not a description. The same logo appearing on every page of every document needs to be recognised once and skipped after that. And when the description fails, the file still has to finish processing, with a clear mark that its images were not described.
Splitting documents into searchable pieces works best when it follows the document's own structure: one piece per slide, per sheet, per section, with a label saying where it came from, so that a search result can say "sheet Security, row 48" and a citation can open the right place. Strip formatting before indexing, but keep the positions in the original. Strip running headers, footers, watermarks and tables of contents too, or they come back as search results and, worse, as extracted requirements.
Search depends on embeddings, and embeddings have versions. When you change the embedding model, every document must be embedded again, and a library with mixed versions returns poor results until that is done. Skip documents whose content has not changed, because editors save often and queues deliver messages twice, and without that check your embedding bill doubles without anyone noticing. A fallback provider for embeddings must produce vectors in the same space, or search returns nonsense the moment the fallback kicks in.
A few more things have to be true of the pipeline. Every file reaches a final state, completed or failed with a reason, and none spins forever; files that do spin are the first thing users report and the last thing they forgive. Deleting a file deletes its pieces and its embeddings too, because deleted content that is still searchable is a quality problem and a privacy problem at the same time. Moving or deleting a file in the middle of processing cancels the processing. New capabilities, such as searching images or slides, apply to new uploads only until you re-process the existing library, and that backfill is a project of its own. The first import of years of past bids outlasts login tokens and network hiccups, so imports must resume where they stopped.
Finding the right passage
Retrieval is where answer quality is won or lost, and most of the work is in the details.
Tender questions are long and indirect. A question such as "Describe your approach to ensuring continuity of service in the event of a major incident affecting your primary data centre, with reference to the standards you hold" retrieves better when it is rewritten into a few focused searches. Weak matches need a cut-off: a passage that is vaguely related invites the model to stretch it into an answer it does not support. Some vector indexes return fewer results than you asked for without telling you, and filters applied after the limit can return an empty page when good matches exist further down.
Permissions have to be applied at the moment of retrieval. If the index does not hold access rights, a question can surface a passage from a document the user is not allowed to open, and the AI will happily quote it. Check access when results come back, fail closed when the check fails, and then make the check fast: checking each hit separately turns one bulk run into thousands of permission lookups. The same rules have to hold everywhere a document can appear: listings, search, downloads, previews, AI answers, image descriptions shared between duplicate files, and chat transcripts a colleague shares. Shared descriptions and shared transcripts are the classic leaks.
Freshness
When two documents disagree about a certificate, a headcount, an insurance amount or a price, the newer one should win and the older one should be flagged rather than used. An answer that cites a ten-year-old file costs more credibility than a missing answer. Struck-through text in a document means a statement was withdrawn, and it must not come back as a commitment. Archived content should not take up search results that current content needs.
Synced folders add their own questions. When a file in SharePoint changes, do you replace your copy, keep both, or keep versions? Replacing loses history. Keeping both creates near-duplicates that the AI mixes. Keeping versions needs a rule for which one answers questions. Whatever you choose, keep the earlier version somewhere before a sync overwrites it, because sooner or later someone will ask what the answer said last month.
Client-specific and confidential material needs a fence. Pricing, a client's own data and anything shared under a non-disclosure agreement must never appear in another client's bid, however relevant it looks to a search engine.
Who keeps it current
Software does not keep a library current. People do. Every library entry needs an owner and a review date, and someone needs time in their week to act on the reminders. Teams that had failed with automation before told us the cause was the same every time: nobody owned the content, the answers drifted out of date, and the tool was blamed for what it produced. Plan the content work as part of the build, with names and hours against it. The RFP library guide covers how to structure it.
Answers you can stand behind
A bid answer is a commitment your company signs. The controls around it therefore have to live in code, not only in a prompt, because a prompt that says "do not invent" does not stop a model from writing something plausible. The same controls apply to everything else the AI writes for a bid: the qualification report, the extracted requirements, the slides.
Grounding and citations
When retrieval finds nothing relevant, the right answer is "we could not confirm this from your documents", with a confidence of zero, and not a fluent paragraph drawn from the model's general knowledge. That sounds obvious. In practice it means the software has to know that retrieval came back empty or weak, and pass that fact to the model and to the reviewer, rather than letting the model decide.
Models cite things that do not exist. They cite a file they were never shown, a page number that sounds right, or a document they read in a previous turn of the conversation and no longer have. Every citation should be checked against what was actually retrieved for that answer, and invented ones removed before anyone sees them. Cite the passages the answer relies on rather than everything that was retrieved, and cite by a stable file identifier so links keep working after a folder is renamed. A detail that is easy to miss: if stored conversations are stripped of their citation markers, the model sees its own earlier answers without citations and gradually stops citing.
Some answers must come only from a defined set of sources, such as the approved security pack or the current tender's documents. When a user restricts the sources, reads outside them should fail with a message, not quietly widen the search. Security and compliance teams often want their approved wording inserted word for word, without the model rephrasing it, and the software needs a way to do that.
"Not found" answers need care of their own. A stock refusal pasted into a bid looks careless; a short statement of what is and is not covered, written for the client, is better. A negative claim ("we do not subcontract any part of the service") needs evidence like any positive one. And the language of traceability has to stay out of the client's copy. Phrases such as "based on the documents provided" or "according to the knowledge base" end up in submitted bids if nothing stops them. Explanations belong in a separate field the reviewer sees and the buyer does not.
Audit your own defaults as well. A platform-level instruction written to be helpful, such as "write TBD when unsure", can override users' own instructions and put drafting notes into proposals. What reviewers need to see in an auditable AI-assisted answer goes into the record behind each answer in more depth.
Review and control
Reviewers need to know where to look first. A confidence score per answer, on a defined scale and with the reasoning behind it, does that, provided the scale means the same thing every time. When generation fails for a question, leave a visible "needs review" marker rather than a blank cell. A blank looks like a question nobody processed, and in a 400-row sheet it gets missed.
Re-running the AI must never overwrite a person's work. An expert corrects an answer, someone re-runs the section an hour later, and the correction is gone: this is the fastest way to lose an expert's goodwill. The software has to detect human edits, leave them alone, and say that it did.
Bulk runs have to add up. After a 500-question run, the counts of answered, needs review, skipped and failed must equal the number of questions found. Silent drops are the most expensive failure in a large questionnaire, because nobody looks for a question that is not on the screen. An agent asked to fill section 3 must not helpfully rewrite sections 1, 2 and 4, and should ask before going beyond what it was asked to do. Changes the AI makes to shared documents need the user's authority, and a record of which text came from the AI and who approved it, because reviewers, legal and sometimes buyers will ask.
Limits, tone and languages
Word and character limits are counted on the rendered text, the way Word or the buyer's portal counts them, not on the markup your system stores. Even a small difference between your count and Word's matters under a hard limit, and buyers do reject answers over the limit; see whether a bid can be rejected for exceeding a word limit. Meeting a limit without damaging the answer is a separate skill. General assistants miss exact counts, pad with repetition or cut a sentence in half. One bid consultant told us that after coaching a model on their voice, asking it to count its own words and having it write long then cut, the answers were still well off the limit. The count has to be done by code, with the model rewriting until the code agrees.
Tone rules come from several places: the company's style, a team or persona, the bid itself, the user's preferences. They need a clear order of precedence, and when two rules conflict the software should ask rather than pick one. "We" is the bidder, and models confuse the bidder, the buyer, partners and the incumbent, especially in reused content written for another bid. Internal file names, colleagues' names and drafting notes have a way of reaching client documents, and personas that were given internal source names have been known to repeat them.
Some tenders arrive in several languages and must be answered in one, which is not always the language of the tender. The teams we speak with bid in Danish, Norwegian, Finnish, Dutch, Polish and Mandarin, not only English, French and German. Extraction, search and drafting all have to work in each, the library has to be searchable across languages, and a glossary has to keep product names and legal terms consistent from one language to the next. Machine translation services have their own quirks with formatting and placeholders, which need handling before the text goes back into a document.
Agents and long-running work
Everything described so far, from shredding a tender to building a deck, is a long job: many model calls, many tool calls, minutes of work, sometimes half an hour. Running that reliably is a different problem from answering a chat message, and most of the bugs live in the space between the two.
What an agent may do
An AI agent that can read the library, write into documents and change a bid is powerful, and it needs boundaries written in code: changes only on the user's authority, and reads only from the sources the user has put in scope. Without those, agents helpfully rewrite neighbouring sections, read documents they were not pointed at and act on instructions they found inside a file. Background information you give the model, such as the company profile or the persona, must be marked as configuration, or the model starts acknowledging it as if it were a request.
Tools need narrow, explicit descriptions of when to use them and when not; a question that happens to begin with a number can otherwise be routed to a calculation tool, and its error shown to the user as the answer. Tool failures must be recoverable by the agent rather than ending the run, and the agent must never report success for a step that did nothing, such as a document "filled" with zero edits. Every claim of completion needs counting behind it: items found, created, skipped and failed, adding up.
Plans, workflows and handoffs
Bid teams want repeatable procedures: for every new tender, summarise it, extract requirements, run qualification, draft the clarification questions. Written only as a prompt, a procedure like that is unreliable; models drop steps and change their order, so the steps need enforcing outside the model. Workflows should run through to the end and stop only for a real reason: a decision only the user can make, an overwrite or deletion, or a step that failed after its best attempt.
Specialist agents, such as one for decks and one for spreadsheets, need clean handoffs: the parent passes a task and a scope, the specialist returns a result, and neither assumes the other's context. Sub-agents need a shared budget for steps, tokens and data, or one of them can consume the whole run.
Stopping, crashing and resuming
Cancellation is full of traps. When a user presses stop, every server that holds part of that run has to stop, not only the one that received the click, or an agent keeps working, and spending, long after the user gave up. Work that runs in parallel inside a run has to listen for the stop signal too, or it keeps scheduling new steps after the user has cancelled. A deadline and a user's cancel are different events and need different handling: a timeout should deliver the work that is finished, not throw it away. Even model providers' own libraries have had bugs in cancellation, so test it.
Long conversations outgrow the model's context window, so older parts have to be summarised, which is called compaction. The summarising step has a size limit too, and when it overflows, every later message in that conversation fails the same way. Steps of a running workflow must survive compaction. Turns need to be written durably, so a crash in the middle of a turn can be recovered or replayed. A turn that must not be replayed, because it already sent something or is waiting for a human decision, has to be parked instead.
Long jobs should not run inside the web request that started them. A deploy or an out-of-memory crash on the web server then ends every run in flight. Put them in a worker with a queue, a heartbeat, and a way for the user's screen to reconnect to the job's progress after a page reload.
Running the AI in production
The models under your tool change several times a year, and each change can alter answer length, tone, citation habits and refusals overnight. Bid teams notice. In calls this year we heard of answers becoming more generic after a model change, of prompts for requirements and bid strategy becoming far more variable, and of users asking whether the answers had been better three weeks earlier. Running AI in production is an ongoing job, separate from building features, and it needs an owner.
Providers, regions and contracts
Enterprise reviewers ask which model provider processes the data, in which region, under which contract, and whether the provider keeps or trains on anything. The answer may differ by business unit or by client: one division may need its data processed in the EU only, another may have a contract with a specific cloud provider. Adding a second provider to a system built for one takes longer than anyone plans for. Model names, parameters, limits, error codes and streaming formats all differ, and configuration tends to drift between the services that call the models. Route every call through one place in the code, so the provider, the model, the region and the limits are decided once.
The same provider can behave differently through different interfaces, for example reasoning less or searching less when tools are attached, and the documentation does not always say so. Only measuring on your own evaluation set will tell you.
Model changes and retirements
Roll out a new model to one group of users first, compare its output with the current one on your own evaluation set, and keep a way back to the model you know. Track the retirement date of every model you depend on. Retired models stop working on a date the provider chooses, and the replacement rarely behaves identically. New models also arrive before your libraries know about them, and settings such as reasoning effort can be ignored without an error. Cheaper models are fine for light work, such as titles and short classifications, and moving that work to them is one of the simpler cost savings.
Tokens, context and cost
Rough token estimates based on character counts undercount Chinese, Japanese and Korean text badly, and a large PDF can be several times the size of a model's context window. Reads need paging, long conversations need compaction, and old tool results in a conversation can be replaced with short stubs once they are no longer needed. Prompt caching changes the cost picture a great deal, and it depends on the order of what you send: content that changes on every call, placed early in the prompt, invalidates the cache for everything after it.
Volume needs managing explicitly. A 500-question workbook cannot be sent at once without hitting rate limits, and answered one question at a time it takes hours. It needs bounded concurrency, a timeout per item, a cancel check between items, and retries for the batches that come back with rows missing or repeated, because a small error rate per batch fails most large sheets. Some checks grow faster than the documents: checking each requirement against a whole response costs roughly the number of requirements times the length of the response, which needs batching and a limit.
Track model cost per operation, per user, per bid and per business unit, from the first day. Buyers asked us what one tender analysis costs, whether they could run out of credits mid-bid, and how to recharge the cost to the business units that use it. Without attribution you cannot answer, cannot budget, and cannot spot the runaway job that spends a month's budget over a weekend. Attribution needs testing like anything else, because a mixed-up identifier or one hung lookup can stop cost records for everyone.
Retries need care with paid services. Classify an error by its type, not its message text, and judge a retried call by its last attempt, not its first, or a permanent failure that followed a rate limit gets retried as if it were temporary. Some services bill on a step you might not expect, such as downloading a translated document rather than uploading the original, and retries have to be designed around that.
Evaluation
Every prompt, model or retrieval change needs testing on a fixed set of real questions with known good answers before it reaches users. Replay production failures as new test cases. Snapshot the settings and feature flags an evaluation run uses; a missing setting can switch a feature on during the test and make the result meaningless.
Some outputs are hard to score. For requirement coverage, a score means nothing until you define precisely what a requirement is: atomic, explicit, scored as covered or not, with the buyer's must and should requirements reported separately. The list of requirements has to be frozen with the test case, or re-running extraction changes the denominator and old scores stop being comparable. When a model grades the answers, its grading has to be checked against human judgement first, and run several times to see how much it varies. Even then, coverage only shows that an answer exists; a vague answer still covers a requirement. Decks and documents need visual scoring on top. Evaluations on real documents cost money and take time, so budget for them, or regressions reach users first.
Logs are part of the AI layer too. Prompts and answers contain the tender and your own confidential material, so keep them out of general logs, error trackers and billing records. Logs are copied to more places, and kept longer, than the data itself.
Every tender is an untrusted file
Every tender pack comes from outside your organisation, and your software opens it automatically, often before a person has looked at it. That makes file handling a security surface and not only a parsing problem.
Office files are zip archives, and a small upload can expand to many gigabytes. Check sizes while unpacking, without trusting the sizes the archive declares about itself, or one file takes down a worker and everything queued behind it. Some files are expensive in other ways: a workbook full of nested formulas, a PDF page drawn from tens of thousands of tiny lines, an image with absurd dimensions. Put limits on formula evaluation, page counts, parse time and geometry work, and run the parsing somewhere a crash cannot take anything else with it.
Parsers have vulnerabilities. PDF.js, the PDF viewer in Firefox and in many web applications, had CVE-2024-4367, which let a crafted PDF run code when it was opened. Image libraries, XML parsers and Office converters have similar histories. Keep them patched, configure them to refuse external references, and run converters with no network access they do not need. Scan every upload for malware before any processing starts, and give users a clear state for a file that was quarantined, rather than one that simply never appears.
Then there is prompt injection. A tender, or a document in your own library, can contain text written to change what the model does: an instruction hidden in white text, a line in a footnote, a cell in a hidden column. OWASP lists prompt injection as the first risk for applications built on large language models, and bid software reads more third-party documents than most. Treat document content as data and never as instructions, keep the model's tools narrow, and stop the AI from editing parts of an Office file it has no business touching, such as logos, hyperlinks, embedded objects and the theme. Pasted text that happens to look like one of your own commands should not trigger it.
One consequence is easy to miss. If a colleague tests prompt injection against your tool, or a hostile document does it for them, the model provider sees abuse coming from your account. Without a per-user or per-team identifier on each call, the provider's only option is to restrict the whole account, and every bid team loses its AI on the same afternoon.
The infrastructure underneath
A prototype runs as one web application calling one model. A bid platform that does everything above runs as a set of services with very different needs, and the infrastructure decisions you make in the first months are the ones that are hardest to change later. This section describes the shape of it, so the business case includes it.
The pieces you will run
At minimum, plan for these:
- a web application and API for the screens users work in;
- workers that process documents: unpacking, scanning, conversion, OCR, splitting, image description, embedding;
- workers that run long AI jobs: answering hundreds of questions, extraction, coverage checks, document and deck generation;
- a real-time service for co-editing and live progress, holding open connections to every active user;
- a document server for editing Office files in the browser, if you offer that;
- queues between all of them, with dead-letter queues for messages that keep failing;
- a relational database for the application's data, and a vector index for search, whether inside the same database or separate;
- a search engine for keyword search, if you need it alongside vector search;
- object storage for the files themselves, with versioning;
- schedulers for the things that happen on a clock: syncing SharePoint, sending reminders, cleaning up stuck jobs, applying retention rules;
- and the external services: model providers, OCR, translation, malware scanning, identity, email.
Each of those has its own scaling behaviour, failure modes, monitoring and cost. Several run all the time whether anyone is bidding or not. Some are heavy: a document server for in-browser editing can need more memory than the rest of your application put together.
Separate the heavy work from the interactive work
The most useful early decision is to keep slow, heavy work away from the processes that serve users. Document conversion, OCR and AI jobs can take minutes and use a lot of memory. If they run inside the web server, one large tender slows everyone's screens, and one crash takes down every user's session and every job in flight.
Inside the workers, separate again. A colleague's bulk import of ten thousand archived files should not leave everyone else waiting hours for a two-page addendum to be processed, so interactive work needs capacity that bulk work cannot take. Heavy job types need the same treatment against each other, or long tasks that take minutes starve quick exports that take seconds.
Slow external calls deserve a pattern of their own. A conversion that takes several minutes should not hold a worker slot while it waits. Submit it, put a check-later message on a delayed queue, and free the slot. Otherwise a handful of large workbooks occupy every slot and everything behind them waits.
Document processing is a memory problem
Parsing Office files and PDFs is far more memory-hungry than the file sizes suggest. A compressed workbook of a few megabytes can expand into hundreds of megabytes of XML. A long PDF converted to an internal format can briefly need several times the memory of the worker processing it, and the worker is killed partway through, every time it retries. Libraries that keep an object per page or per block alive until the end of a loop are a common cause. So are office converters started once per request; under parallel load they run the machine out of memory.
Plan for limits on everything: upload size, decompressed size, page count, number of slides, image dimensions, time per file. Run converters as separate processes you can kill, with their own temporary directories, and kill the whole process group when a user cancels, or the converter carries on to its timeout after nobody wants the result. Image libraries come with defaults meant for desktop use, such as large caches and many threads, which need turning down on a server.
External conversion and OCR services fail in ways you would not guess. A service can report a job as complete and failed at the same time, in two different fields, and code that reads only one of them stores empty documents as processed. Rate limits can arrive as HTTP errors or as a normal-looking result. Read every field a service returns, and test the failure paths on purpose.
The data layer
Bid platforms put a lot into the database: the bids, the documents' metadata, the extracted items, the answers and their versions, the permissions, the audit log, the jobs, and often the search vectors too. It is tempting to keep it all in one database, and for a long time that works. Then a database that serves both the application and vector search can degrade gradually rather than suddenly. The working set outgrows memory, reads go to disk, the disk runs out of burst capacity, background maintenance on the largest table competes with users, and an expensive count query tips it over. It happens over weeks, and if the only alarm is on free disk space, nobody sees it coming. Watch read latency, memory, disk queue depth and the slowest queries from the start, and ship the slow-query log somewhere you can actually read it.
Vector indexes have their own operational life. Building an index on a large table can lock out writes, so it has to be built concurrently, which cannot run inside a transaction and can leave an invalid index behind if it is interrupted. Later migrations then skip it because an index of that name exists. Filtered searches can return fewer results than requested unless the index's search parameters are raised. Changing how text is split and stored, which you will want to do as you learn, needs a phased plan: write to the old and new tables at once, switch reading over one customer at a time, and keep the old table until you are sure.
Connections are the next constraint. Every service, worker and scheduled function holds database connections, and the database has a limit. A connection pooler helps, and brings restrictions, such as settings it refuses at connection time. Idle connections closed by the pooler can crash the application if the pool does not expect it. The default wait for a free connection in many libraries is forever. A function that takes a second connection while holding one can deadlock a small pool.
Files live in object storage, and the paths between your services and storage need timeouts. A storage read that never returns, while holding a lock, can freeze everything that waits on that lock. Some runtimes ignore the timeout settings of the cloud provider's own libraries, which is the kind of thing you find out in production.
Real time and co-editing
Live co-editing and live progress need a service that holds a connection to every active user and keeps shared documents in memory. Scaling that out across several servers needs a way for them to share state, and many teams start with one server and plan to add the rest later. Either way, a crash or deploy disconnects everyone at once, and if every client reconnects after exactly the same delay, they knock the server over again the moment it comes back. Reconnection needs random delays that really spread out, and clients need to reload what they missed rather than assume they received every update. Editing history grows without limit unless it is compacted, and the compaction job must not race the edits being saved at the same time.
Regions and residency
If some business units or clients need everything to run in the EU and others in the US, plan for it from the first day. Running fully in a region means the data, the files, the search index, the backups and the AI processing all stay there, and infrastructure written for one region carries assumptions about it everywhere. The residency of your suppliers matters as much as your own: the model provider, the OCR service, the translation service and the identity provider each process content somewhere, under their own contract. Your InfoSec team will ask about each of them.
Robustness: what has to be true when things fail
Bid software is used hardest in the last forty-eight hours before a deadline, which is exactly when a failure costs most. A prospect asked us this year what happens if the tool is down before a multi-million submission. Another asked for our disaster recovery plan and recovery time. Teams that had used other tools described deployments during office hours that left the tool unusable, and runs that stopped without an error message, leaving questions blank. You cannot add robustness at the end. It comes from a handful of properties that every part of the system has from the start.
Every job ends
Every file and every job needs a defined set of states, from received through scanning and processing to completed or failed, and it must always reach one of the final ones. A file that sits in "processing" forever is the first thing users report and the hardest to explain. That means deadlines on every stage, sweepers that find work stuck beyond its deadline and fail it with a reason, and a visible state for every failure, such as "quarantined", "could not be read", "too large", so users know what to do next.
Temporary and permanent failures are different
A network blip and a corrupt file are different failures and need different handling. Retry the first, with a delay that grows each time; fail the second immediately. If you do not distinguish them, two bad things happen. Either temporary failures fail files that would have worked a minute later, or permanent failures are retried forever. A worker that acknowledges every message, successful or not, never sends anything to its dead-letter queue, and a network hiccup fails a file as permanently as a corrupt one. Classify errors by their type and code, never by the wording of the message, which changes between library versions. A connection reset that arrives after the other side has already answered successfully is not a failure of the request.
Dead-letter queues only help if someone looks at them. A dead-letter queue that sits in alarm for months is a list of customers' files that never finished.
Everything runs twice
Queues deliver messages more than once, workers crash after doing the work but before recording it, and users click buttons twice. Every job has to be safe to repeat: writing the same answer twice must leave one answer, processing a file twice must leave one set of search entries, and a paid call must not be paid for twice if you can avoid it. The techniques are ordinary, such as unique keys, status checks before each step, records of what has been done written in the same transaction as the work, and claims that expire. They have to be applied everywhere, though, including the places nobody thought of as a job. A subtle version: a worker fetches more messages than it can work on at once, the waiting ones time out, the queue hands them to another worker, and they are processed twice.
Two runs on the same item at the same time are the other half of the problem. Two re-index runs on the same file, two renames of the same folder on two servers, a compaction job and a live save: each needs a lock or a version check, and a lock held inside one process does nothing for a second server.
Every call has a timeout
Many libraries wait forever by default: for a database connection, a storage read, a queue receive, a third-party API. One call that never returns can hold a lock, a worker slot or a user's session indefinitely. Put a timeout on every external call, including the DNS lookup before it, and make sure the timeout actually works in your runtime. Then decide what happens when it fires, and test it.
Health checks that tell the truth
A health check that always answers "OK" hides a process that is alive but stuck. A health check that is too strict kills processes that are busy but fine. Long AI turns can block a server process in short bursts, and a default load-balancer check will then kill agents that are working normally, while a process whose configuration never loaded can keep reporting healthy as every request fails. Decide what "healthy" means for each service, and make a process that has hit an unexpected error exit and restart rather than limp on, because a corrupted process that still answers health checks is the worst state to be in.
Deploys, migrations and rollbacks
You will deploy often, and bid teams will be working when you do. Deploys have to roll through servers gradually, workers have to finish or hand back their current work inside the platform's stop window, and long-running AI jobs need to survive a deploy or resume after it. Database migrations must work while the old code is still running, which means adding before removing and changing data in small batches so tables are not locked for minutes. Migrations on large live tables need a limit on how long they wait for locks, or a single migration stalls the whole release without a log line. Promote a release in stages, migrations first, then the services that own data, then the workers, and stop if a stage does not settle. Know how you roll back, including the database, before you need to.
Feature flags help here: ship new code switched off, turn it on for one team, then for everyone, then delete the flag. Turning a flag off must never strand work that started while it was on. Kill switches for expensive features, checked before the paid call rather than after, let you stop a runaway cost without a deploy.
Backups and recovery
Back up the database and the files, keep earlier versions of files, and protect the storage from accidental deletion. Then restore from the backups regularly, into a separate environment, and time it, because a backup you have never restored is a hope rather than a plan. Write down how much data you can afford to lose and how long you can afford to be down, and check that the setup delivers it. Do not forget the services whose state is easy to overlook: the search index, the document server's storage, the queues, the secrets. Customers will ask for these figures in their security questionnaire, and some will write them into the contract.
Scalability: the shapes of load
Bid software does not see smooth, predictable traffic. Its load comes in shapes, and each shape breaks something different.
The first is the deadline spike. Several teams submit in the same week, often on the same day, and usage the evening before a deadline can be several times a normal morning. Capacity planned for the average fails exactly when it matters. Fixed server counts that someone changes by hand after a crash are how many internal tools start, and how they stay until the first bad week.
The second is the very large single job. A 600-page tender, a workbook with a thousand rows, a template with a hundred slides and embedded video, a comparison of two long versions of the same tender. Bid teams told us of splitting a response of well over a hundred pages into pieces because the tool was so slow, of leaving a long run for an hour, and of a comparison that hit its limits on exactly the large reissued tender where it mattered. Each of these needs streaming rather than loading everything into memory, work split into pieces with progress saved after each, and limits that fail early with a clear message rather than late with a crash.
The third is the bulk import. The first sync of a large SharePoint site, or the migration of years of past bids, is many thousands of files arriving at once. It must not delay anyone's live work, it has to resume after interruptions, and its cost has to be predictable, because every file goes through conversion, image description and embedding.
The fourth is the noisy neighbour. Whether your tenants are customers or business units, one of them will at some point run something heavy, and the others must not notice. Every shared resource needs a per-tenant limit: processing lanes, job slots, search throughput, API rate limits, model spend. A rate limiter that writes to the database for every refused request becomes a load problem in itself, so refused requests need to be turned away in memory.
The fifth is growth over time. Libraries grow, conversations grow, version histories grow, audit logs grow, the vector index grows, and queries that were fast with ten customers' data do full table scans with fifty. Missing indexes show up under load, typically on version histories, chat history and folder listings, and lists that load item by item turn one page view into hundreds of queries. Measure the query plans of the busiest screens as data grows, not once at launch.
Model rate limits sit on top of all five. Your provider gives you a number of tokens and requests per minute, shared by every user and every job. A bulk run by one team can use up the limit for everyone, so AI work needs a queue, priorities and per-tenant shares, and interactive questions should not wait behind a thousand-row batch.
Operations: watching it and running it
Once the tool is live, someone has to know when it is broken before the bid team does, and fix it at eleven at night before a deadline.
Monitoring and alerting
Monitor what users experience, not only what servers report. Error rates and response times per service, queue depth and the age of the oldest message, processing time per file, job success rates, model errors and latency, cost per hour, and the health of each integration. Alert on the oldest message in a queue, not only on the number of messages, because a queue that is not moving is worse than a long one.
Two lessons are worth learning early. Alarm thresholds copied from averages fire constantly and get ignored; set them from real incidents and from percentiles. And some alarms recover on their own while one customer is still completely stuck, because that customer's users give up and stop sending requests. You need to be able to see problems per customer or business unit without putting customer data into your metrics, which usually means logs that can be filtered by tenant and metrics that are not.
Memory graphs mislead because they are samples, and the moment a process is killed for running out of memory falls between samples. The platform's own record of why a process stopped is the source of truth. Record the size of the inputs to heavy jobs, so that when one runs out of memory you can tell which document caused it.
Tracing across services, from the user's click through the API, the queue, the worker and the model call, turns a vague "it was slow" into a specific answer. Set it up early; it is much harder to add once there are ten services.
Support and admin tools
Without proper admin tools, support works through hand-written database scripts: re-running a stuck file, re-importing a folder, deleting a user's data, checking why a bid looks wrong, often with credentials copied from somewhere they should not be. That is slow and risky. Plan admin screens for the operations support does every week, with an audit log of their own, and just-in-time access to production data, approved and time-limited, for everything else.
Security operations
Security is a running cost, not a launch task. Dependencies need patching continuously, and document parsers and AI libraries publish vulnerabilities often. Automated scanning of dependencies and container images, with someone responsible for acting on the findings, is the minimum. Lock files must be respected in every build, because a build tool that quietly installs other versions can take a service down in production. Secrets belong in a secrets manager, injected at start-up, with rotation that works without downtime. Credentials for customers' SharePoint, Teams and email need encryption tied to the record they belong to, so a copied value cannot be used elsewhere, and a process for re-encrypting them when a key changes. Outbound requests, such as webhooks, fetching images for documents and following redirects from document stores, need checks against requests to internal addresses at every hop. Human access to production should be the exception, approved and logged. And plan for the independent penetration tests and audits your customers, or your own InfoSec team, will ask to see.
Environments and releases
You need at least one environment that is not production, with realistic data volumes, where releases are tested before customers see them. Infrastructure belongs in code, applied through a reviewed pipeline, with a regular check that what is running matches what the code says; changes made by hand in a console during an incident have a way of being reverted by the next unrelated deployment. Tests should run against a real database rather than mocks, because many of the bugs above, such as lock races, missing indexes and connection pool exhaustion, never appear against a mock. Evaluations of AI output belong in the release process too, or quality regressions ship like any other bug.
The enterprise platform
An internal tool that processes tender documents is still an enterprise application. Your InfoSec, legal and AI governance teams will review it the way they review any vendor, and the platform work is often larger than the AI work.
Isolation, identity and permissions
Whether you serve one company with several business units or many companies, every query, cache entry, file key, search index, log line, background job and real-time channel has to be scoped to the right one. One missing filter shows one division's pricing to another. Background workers deserve particular suspicion: they act on whatever identifiers they receive in a message, so they have to check ownership themselves rather than trust that the API already did. Storage keys must not be guessable or forgeable from the outside. The link between an external workspace, such as a Slack or Teams tenant, and an organisation must be one to one, and enforced by the database, because application code that checks first and writes second can race.
Enterprise IT will not approve a tool with its own passwords, so single sign-on through the company's identity provider is the starting point, with multi-factor authentication where the policy requires it. Joiners and leavers should be handled automatically. Manual offboarding leaves former employees with access to live bids, and removing a user has to reach every integration they connected, not only the login. Bid days are long, and a session token that expires in the middle of an edit must not lose the edit.
A role field on the user is not a permission model. Once bids involve partners, external reviewers, legal and restricted pricing, you need permissions per project, folder and knowledge source, with groups and inheritance, and rules that hold under pressure: a missing owner never means "everyone", a user identifier is never reused for a different person, and changing a permission while someone is working takes effect without a race. Permissions also apply to what the AI produces. An answer drafted from a restricted document inherits the restriction, and so does a chat transcript that quoted it.
Other systems will want access too. Integrations need API keys that expire, carry scopes and have their own rate limits, and tools that connect through the Model Context Protocol need proper OAuth rather than a shared secret.
Security, privacy and compliance
Reviewers will ask where data is stored and where the model calls are processed, and whether everything, the AI included, stays in the EU, the UK or the US. They will ask for written confirmation that no model provider trains on your content; it is among the first questions in any review. Credentials for SharePoint, Teams, Google Drive and email have to be encrypted, with a way to rotate the keys. Webhooks and any other outbound calls need protection against server-side request forgery, including addresses that resolve to one place when checked and another when called. Customer content, file names and secrets stay out of logs, because logs are copied to more places and kept longer than the data itself.
Keep an append-only audit log of who did what, one that survives renames and deletions. Buyers, auditors and your own legal team will ask who wrote and who approved an answer, sometimes years later. Deletion needs more design than it gets: a recoverable delete for users, a defined meaning for "archive", and the ability to erase a person or an entire business unit from every store, search indexes and embeddings included. The GDPR right to erasure applies to your tool as it does to any other. People who leave should be anonymised without destroying the content they wrote, and a purge job must never be able to reach across into another organisation's data. Retention rules need automating, and every new table or store you add later needs adding to the purge, which is why it helps to have a check that fails when one is missing.
Expect to answer your own company's vendor security questionnaire for the tool, and plan for the controls behind ISO 27001 or SOC 2 if other business units, subsidiaries or partners will use it. Using AI to answer security questionnaires shows what those questionnaires ask. Ask legal for a written view on the EU AI Act and your sector's rules as well; whether the EU AI Act applies to bid writing is a good place to start.
Integrations
Bid content lives in SharePoint, OneDrive, Google Drive, Teams and Slack, and the team expects the tool to read it where it is. Syncing a document store properly means handling deletions that arrive with nothing but an identifier, renames and moves applied in the right order, paging and throttling on large sites, folders the integration loses access to, and re-syncs that must not overwrite a file someone uploaded by hand. Teams and Slack each need their own app, with a manifest, a platform review, tokens per workspace, and clear states for connections that are paused, broken or uninstalled. Email notifications need per-user preferences and digests. Account and opportunity data lives in the CRM; decide whether you need it at launch or later. Other teams will want to start a bid or read results from their own systems, through an API with webhooks that retry when the receiving end is down.
The team and the budget
The team you need is broader than the AI team most organisations already have. Count the roles, each with time set aside for years rather than months:
- a product owner from the bid team, who can name the steps that take longest and say no to features that only look good in a demo;
- backend engineers for the platform, the integrations and the job pipeline;
- at least one engineer who specialises in document formats, because Excel, Word, PDF and PowerPoint handling is a discipline of its own and the bugs never stop arriving;
- an engineer for search, models and evaluation;
- frontend engineers for the workflow, the editors and the review screens;
- infrastructure, security and on-call support, because the tool runs at night before deadlines too;
- content owners for each subject area of the library.
When bid teams describe their own build estimates to us, their colleagues often call the estimate optimistic, and the first version is not where most of the money goes. The larger cost is the work that keeps going once the tool is live. Models are released and retired. Buyers send file formats nobody has seen. Parsers and libraries need security patches. Providers change their APIs and their prices. SharePoint sites get reorganised. The library needs curating, the evaluations need running, the infrastructure needs watching, and your InfoSec team reviews the tool again every year. That work is indirect and easy to leave out of a business case, which is exactly why it belongs in one.
To put figures on it, the build vs buy calculator compares three years of building your own platform, setting up general AI tools on your document store, and buying a specialist product, using your own numbers.
When building makes sense
Building can be the right decision. It usually is when the scope is narrow and stays narrow: one document type, one language, one file format you control, such as an internal search over an approved library for a single team. It can be when your bids depend on a system or a process that no product supports and the difference is worth owning. It needs a committed team: engineers with a mandate measured in years, a product owner from the bid team, and content owners with time to curate. And many organisations take a middle route. They buy the platform and build only what is specific to them through its API, such as a link to an internal pricing engine or a data warehouse.
It tends to be the wrong decision when the main reason is that general AI licences are already paid for. The licences are the cheap part. Where a specialist tool fits into your enterprise AI strategy covers how the two sit together.
Whichever way you lean, test the decision the same way. Run your current way of working, your prototype and any product on your shortlist on the same closed bid, with its real files, and compare the output and the hours. How to choose RFP response software on a closed bid explains how to run that trial, and the RFP template for choosing RFP software gives you the requirements to send to vendors.
How SEQUESTO handles this for you
We built SEQUESTO aOS™ because we hit every item on this list ourselves, and we keep hitting new ones as buyers send new files and models change. SEQUESTO aOS is the agentic operating system for bid and tender teams. It covers the bid from the tender pack to the submitted files: qualification, extraction of requirements and key facts, the buyer's own Excel, Word, PDF and PowerPoint files filled in place, proposal documents and decks in your template, review and approval. It drafts from your company's documents where they already sit in SharePoint, Teams, Google Drive or Slack, cites its sources, and leaves the final word to your team. SEQUESTO runs fully in the EU or fully in the US: each customer chooses its region when the account is created, and its data and the AI stay in that region. No AI model provider trains on customer data, and SEQUESTO is ISO 27001 and SOC 2 Type II certified. James, SEQUESTO's AI bid agent, does the work; your bid manager reviews and signs off. See SEQUESTO aOS, or bring one of your own tenders to a live demo.
The checklist
The checklist for building your own RFP response software is a free Excel workbook with every item in this guide as a single line, grouped by section, with a priority, status and owner to fill in and a summary that counts what is still open. Every item applies just as much to a product you are evaluating, so you can send the same list to vendors. The short version, to check before you commit:
- You have listed every bid document type and file format you answered last year, and each is in scope or explicitly out.
- You know which steps of the bid you are building for, from qualification to the submitted files, and who does the rest by hand.
- You have collected real buyer files for testing: protected workbooks with drop-downs on hidden sheets, Word forms with legacy fields, flat and scanned PDFs, a long tender with a compliance matrix, your own Word and PowerPoint templates.
- Your tool returns the buyer's own file, filled in, and Excel never offers to repair it.
- Every extracted requirement links back to its source, and the counts reconcile.
- Every answer cites sources that exist, says so when it cannot find an answer, and never overwrites a person's edit.
- Every library entry has an owner and a review date, and someone has time to act on them.
- Permissions apply at retrieval time and to everything the AI produces.
- Long jobs run outside the web servers, survive a deploy, stop when the user stops them, and always end.
- You know how the system behaves the evening before a deadline, with three teams submitting at once.
- InfoSec has approved the data flows, model providers and hosting regions in writing.
- There is a named team and a yearly budget for running the tool after launch.
- You have compared the build, on the same closed bid, with your current way of working and at least one product.
Frequently Asked Questions
Sources
- Excel specifications and limits, Microsoft
- CVE-2024-4367 detail, NIST National Vulnerability Database
- LLM01:2025 Prompt Injection, OWASP Gen AI Security Project
- Regulation (EU) 2016/679 (General Data Protection Regulation), EUR-Lex
- ECMA-376 Office Open XML file formats, Ecma International
