AI idea: automatic tender digest from public procurement to email

Public procurement is an interesting source of business opportunities for many companies, but tracking it manually is time-consuming. The problem is often not just finding new tenders themselves, but mainly sorting them continuously, distinguishing relevant cases from noise, and quickly passing information to the sales team. This is exactly where a small but practical AI project makes sense: an automatic tender digest that downloads new contracts once a day, sorts them according to your rules, summarizes them briefly, and sends them by email in a readable format.

The advantage of such a solution is that you do not have to start with a complex enterprise integration. For a functional MVP, a combination of a publicly available data source, a database table, an automation platform, a simple AI step, and email sending is enough. If you already have experience with automations, implementation will be fast. If not, this project is still suitable because it can be built in small steps and each step is easy to verify.

In this guide, we will build a specific minimum viable product. The goal will not be a perfect procurement system, but a reliable daily digest of relevant contracts for a specific company or sales team. The process is intentionally designed to be feasible without your own backend, using real services and verifiable settings. If you work more deeply with AI automations, you may also find our overview of AI automations useful, or related content on tools for ChatGPT and practical workflows.

Project goal

The goal of the project is to create a daily or weekday-triggered email overview of public contracts that automatically:

NordVPN

loads new records from a public source,
filters contracts by sector, region, value, or keywords,
uses AI to prepare a short summary and relevance estimate,
groups the results into one email,
prevents duplicate sending of the same contract.

The typical user of such an MVP is a salesperson, consultant, agency, or supplier of IT, construction, marketing, or service solutions who wants to receive only what matters each day. The practical output of the project is clear: instead of manually reading dozens of items, a short digest with links, deadlines, and the reason why the contract is relevant arrives in the inbox.

Prerequisites

Before you begin, prepare a few basic things. The first is a data source. For the Czech environment, it is possible to use public procurement data from official sources or their open interfaces, if they are available for the given type of data. The availability of specific endpoints and their limits may change, so it is necessary to verify current conditions and documentation before deployment. If a source does not offer a simple API, you can also start with a CSV or RSS export, if available.

Zapier

You will also need an automation tool. In this guide, we will use Make because it combines HTTP requests, working with tables, OpenAI, and email well. Alternatives include Zapier, n8n, or a custom script. As storage, we will use Airtable because it makes filtering, deduplication, and manual review easier. For AI summaries, we will use the OpenAI API. We will send email via Gmail or SMTP.

Also prepare a list of business rules. Specifically: which keywords interest you, which regions, the minimum contract value, which CPV codes you want to monitor, and who the digest should be sent to. Without these inputs, AI could summarize the text, but it would not assess business relevance well.

Implementation steps

Step 1: Define filtering rules and the data model

What and why: Before you automate anything, you must define exactly what should be considered a relevant contract. Without that, you will end up with an email full of noise. The goal of the first step is to translate the business brief into specific fields that you will later use in the automation and in the AI prompt.

OpenAI

How exactly: In Airtable, create a base called Tender Digest and a table Tenders. Add at least these fields: tender_id, title, buyer, description, cpv_code, estimated_value, currency, region, deadline, source_url, matched_keywords, ai_summary, ai_relevance_score, sent_in_digest. Then create a second table Rules with the fields keywords_include, keywords_exclude, min_value, regions, cpv_include, email_to.

Example input for the Rules table:

keywords_include: cloud, helpdesk, cybersecurity, server maintenance
keywords_exclude: furniture, food
min_value: 500000
regions: Prague; Central Bohemian Region
cpv_include: 72000000, 72250000, 48800000
email_to: sales@company.cz

The expected output is a clear data model and a set of rules that the rest of the workflow will use. Success metric: you can take five real contracts and, for each one, determine without hesitation whether it should pass the filter and why.

This step is also important for less advanced users. If you do not write down the rules in advance, you will later be tuning AI where the real problem is in the input criteria. So first decide what you are looking for, and only then automate it.

Step 2: Connect the public procurement source and load the first data

What and why: Now you need to get real records into the workflow. The point of this step is to verify that you can regularly load new tenders and map them into fields in Airtable. Do not deal with AI or email yet. Focus only on reliable data acquisition.

How exactly: In Make, create a new scenario. As the first module, add Scheduler and set it to run, for example, at Every day at 06:30 Europe/Prague. Then add the module HTTP > Make a request. In it, set the method to GET, the URL according to the selected official source, and a time filter parameter if the API supports it. A typical input may look like this:

Method: GET
URL: https://example-official-source.cz/api/tenders
Query string:
published_from=2026-03-11
limit=100
format=json

If the source returns JSON, add JSON > Parse JSON. Map fields such as id, title, description, buyer_name, estimated_value, deadline_date, and url. Then use Airtable > Create a record and save the data into the Tenders table.

Example of simple mapping:

API input:
{
  "id": "VZ-2026-001245",
  "title": "Cloud infrastructure management",
  "buyer_name": "Prague 6 Municipal District",
  "estimated_value": 2400000,
  "deadline_date": "2026-03-28",
  "url": "https://example-official-source.cz/tender/VZ-2026-001245"
}

Airtable output:
tender_id = VZ-2026-001245
title = Cloud infrastructure management
buyer = Prague 6 Municipal District
estimated_value = 2400000
deadline = 2026-03-28
source_url = https://example-official-source.cz/tender/VZ-2026-001245

Output: the Airtable table contains the first loaded contracts. Success metric: at least 95% of fields from the API are mapped correctly, and for at least 20 records, key information such as title, deadline, and URL is preserved.

Once the data is flowing into the table, you can move from simple collection to sorting it. This is important because without filtering, the digest would quickly lose its value.

Step 3: Add deduplication and a basic business filter

What and why: Public data often contains updates to the same contract, repeated records, or items that are not relevant to you. The goal of this step is to prevent duplicates and let through only contracts that meet the basic business conditions.

How exactly: In Make, after the data loading module, insert Airtable > Search records and search by tender_id. Use the formula expression:

{tender_id} = "{{id_from_API}}"

If the record exists, end the workflow or update only selected fields. If it does not exist, create a new record. Then add a Filter in Make with specific conditions. For example:

estimated_value >= 500000
region contains Prague or Central Bohemian Region
title + description contains one of the keywords from the Rules table
title + description does not contain exclusion words such as furniture

For a simpler version, you can use the matched_keywords field, where you store the words found. For example, via the Text parser module or simple JavaScript in the Code module in Make.

Input:
title = Delivery of a helpdesk system and service support
description = The subject of performance is a new helpdesk and integration with identity management

Output:
matched_keywords = helpdesk; service
basic_filter_pass = true

Output: only new and basically relevant contracts remain in the table. Success metric: the share of duplicates after one week of operation is below 2%, and at least 70% of contracts that pass the filter are actually relevant during manual review.

This intermediate step intentionally comes before AI. It is cheaper to filter out noise with rules than to send everything to a language model. Only for a narrower selection does it make sense to deploy summarization and relevance scoring.

Step 4: Create an AI summary and relevance score

What and why: A salesperson does not need to read the full contract text. He needs to quickly understand what is being requested, what the deadline is, what the value is, and why it is interesting specifically for his company. The role of AI in this step is not to replace legal reading of the tender documentation, but to create a concise and consistent overview.

How exactly: In Make, add the module OpenAI > Create a Chat Completion or the corresponding official module according to the current integration offering. As the model, choose for example gpt-4o-mini, if it is available in your account. In the prompt, send the title, description, buyer, value, deadline, and your business preferences from the Rules table.

Example system instruction:

You are a public procurement analyst. Return JSON with the structure:
{
  "summary_cz": "max 70 words",
  "relevance_score": 0-100,
  "why_relevant": "max 30 words",
  "risk_note": "max 25 words"
}
Increase the score if the contract matches the keywords, CPV codes, and region. If you are unsure, give a lower score.

Example user input:

Title: Cloud infrastructure management
Buyer: Prague 6 Municipal District
Description: We are looking for a supplier for virtualization management, backup solutions, and 24/7 monitoring.
CPV: 72250000
Value: 2400000 CZK
Region: Prague
Deadline: 2026-03-28
Our priorities: cloud, helpdesk, cybersecurity, server maintenance
Minimum value: 500000 CZK

Expected model output:

{
  "summary_cz": "The contract concerns management of cloud and virtualization infrastructure including backups and continuous monitoring. For an IT supplier with a service model, this is a directly relevant opportunity.",
  "relevance_score": 91,
  "why_relevant": "Matches cloud, server maintenance, and the Prague region.",
  "risk_note": "Detailed SLA and qualification requirements must be verified."
}

Save the result into the fields ai_summary, ai_relevance_score, why_relevant, and risk_note. Success metric: at least 80% of AI summaries are factually correct during manual review, and the relevance score helps distinguish the top 20% most interesting contracts.

For less advanced users, one rule is important: ask the model for structured output. JSON is easier to validate, store, and display in an email than free text.

Step 5: Build the daily digest in an HTML email

What and why: Once you have relevant contracts and their summaries, it is time to turn them into a format that someone will actually open and read. The goal is to create a concise digest with a consistent structure so that the recipient can see within two minutes what deserves attention.

How exactly: In Make, create a second scenario or a follow-up branch that runs once a day after the data has been loaded and processed. Using Airtable > Search records, filter records that have sent_in_digest = false and for example ai_relevance_score >= 70. Then use Tools > Text aggregator or Array aggregator and compose an HTML block for each contract.

Example HTML template for one item:

{{title}}
Buyer: {{buyer}}

Value: {{estimated_value}} {{currency}}

Deadline: {{deadline}}

Relevance: {{ai_relevance_score}}/100
{{ai_summary}}
Why it is relevant: {{why_relevant}}

Note: {{risk_note}}
Open contract detail

Set the email subject for example to Daily tender digest | 6 relevant contracts | 12 Mar 2026. For sending, use Gmail > Send an email. In the To field, map the address from the Rules table, for example sales@company.cz.

Output: the recipient receives one clear email with a list of relevant contracts. Success metric: open rate above 50% for the internal team and an average digest length of up to 10 items so that it remains readable.

Once the email works, one final practical detail remains: ensuring the same contracts are not sent repeatedly and that it is easy to trace what has already been sent.

Step 6: Mark sent records and add an audit trail

What and why: Without marking sent items back in the system, it will start sending duplicate digests or you will lose track of what was sent and when. The goal is to close the loop and turn the MVP into an operationally usable tool.

How exactly: After the email is sent successfully, add the Airtable > Update a record module in Make and set sent_in_digest = true and digest_sent_at = now() for all included contracts. I also recommend adding the field digest_batch_id, for example in the format 2026-03-12-morning. In case of a sending error, do not make the change so that the items are retried on the next run.

Example input and output:

Input:
record_id = recA1B2C3
sent_in_digest = false

expected output after sending:
sent_in_digest = true
digest_sent_at = 2026-03-12T06:35:22+01:00
digest_batch_id = 2026-03-12-morning

Optionally, create a third table Digest Log with the fields batch_id, records_count, email_to, status, sent_at. This helps a lot with later debugging.

Output: the system can reliably distinguish new items from already sent ones. Success metric: zero duplicate-sent contracts during five consecutive days of operation.

This creates a functional MVP. But for it to be truly usable, you still need to verify the quality of the output on real data, not just that the workflow technically completes.

Step 7: Fine-tune relevance using a simple feedback field

What and why: After a few days of operation, you will find that some contracts are textually similar but commercially unpromising. That is why it is worth adding simple user feedback. The goal is not machine learning in the full sense, but practical tuning of rules and the prompt according to reality.

How exactly: Add the field user_feedback to the Tenders table with the values relevant, borderline, irrelevant. Once every few days, have a salesperson rate 20 to 30 delivered items. In Make, you can then add a condition that lowers the priority of contracts with features similar to previously marked irrelevant cases. At the same time, adjust the prompt, for example by adding the sentence:

If the contract contains only general IT services without a clear link to cloud, security, or server management, lower relevance_score below 60.

Example input:

title = Framework agreement for office ICT equipment
user_feedback = irrelevant

Expected output after adjusting the rules:

for similar future contracts, ai_relevance_score will decrease for example from 74 to 48

Output: the relevance of the digest improves according to the team’s actual preferences. Success metric: after two feedback iterations, the share of useful items in the digest increases by at least 15%.

Testing

Divide testing into three layers. The first is technical testing of the data flow. Verify that records load correctly, that the right fields are mapped, and that JSON parsing does not fail. The second layer is content-related. Select at least 30 contracts from recent days and manually compare whether the filter and AI score match expectations. The third layer is operational: monitor whether the email is delivered at the correct time and without duplicates.

NordVPN

A practical testing checklist may look like this:

A contract with a value of CZK 300,000 must not get into the digest if min_value = 500000.
A contract with the keyword cloud and CPV 72250000 must pass to the AI step.
The same tender_id must not create a second record.
The model must return valid JSON without extra free text.
The email must contain a working source_url link.

A good minimum quality metric for the MVP is this: out of 20 items in the digest, at least 14 are evaluated by the user as commercially useful. If you are significantly below this threshold, do not solve additional features yet and return to the filters, keywords, and prompt.

Deployment

For deployment into regular operation, set a fixed runtime in Make, ideally before the start of the workday. For Czech teams, 06:30 or 07:00 makes sense. At the same time, set up a notification for scenario errors. In Make, you do this in the scenario settings via alerts for unsuccessful runs. If you use Gmail, verify sending limits and the reputation of the sending address.

Make

In Airtable, I recommend creating the views New filtered, Sent today, and Low confidence. The last view can filter records with ai_relevance_score between 50 and 69 that are worth occasional manual review. This gives the MVP deployment practical operability: you know what came in, what went out, and what deserves fine-tuning.

If you will use the system for multiple teams, do not put everything into one digest. It is better to have a separate rules table and generate a digest for each segment separately, for example IT infrastructure, marketing services, or construction projects. Otherwise, relevance will quickly decline.

Limits

The first limit is the data source. In public procurement, formats, API availability, description quality, and metadata completeness may change. If a source does not provide a well-structured field for CPV, region, or value, filtering will be less precise. This needs to be understood as an input limitation, not a failure of AI itself.

NordVPN

The second limit is text interpretation. A language model can summarize well, but it may not correctly understand legal nuances, qualification requirements, or hidden exclusions. Therefore, the digest must not replace final human assessment. It is a tool for preselection, not a legal or business verdict.

The third limit is cost and speed. If you send hundreds of long descriptions to AI every day, costs will grow. In practice, it is therefore worth using a simple rule-based filter first and only then AI. That is exactly how this process is designed.

The fourth limit is relevance across sectors. One prompt will not work equally well for IT services, construction, and medical technology. If you monitor multiple segments, it is better to have separate rules and a slightly adjusted instruction for the model for each of them.

FAQ

Is it possible to build the project without Airtable?

Yes. Instead of Airtable, you can use Google Sheets, PostgreSQL, Notion, or an internal CRM. For an MVP, however, Airtable is practical because it combines a database, filtering, and manual review without programming.

Do I have to use OpenAI?

No. You can also use another model available via API, as long as it can reliably return structured output. In this guide, OpenAI is chosen because of simple integration and broad availability.

How often should the digest be sent?

Most often once a day on working days. If there are many contracts, you can also add a midday run. For smaller segments, a summary three times a week may be enough. The deciding factor is that the email should not be too long and should not lose readability.

What if AI returns inconsistent summaries?

First, make the prompt more precise and require JSON with a fixed structure. Then shorten the input to only the important fields. If the problem persists, add output validation and, in case of error, use a fallback rule-based summary from the database fields.

Can I add priority or a recommended next action to the digest?

Yes. Add the field next_action, for example verify qualification, send to salesperson, or ignore. But clearly state in the prompt that this is only a guidance recommendation, not a binding decision.

Is it appropriate to send full tender documentation to the model?

For an MVP, usually not. It is more expensive, slower, and often unnecessary. First work with metadata and a short contract description. Full documents make sense only in the second phase of the project for more detailed analysis of shortlisted cases.

Recommended AI stack for implementation

Service	Service description	Offer
NordVPN	VPN service for privacy protection and secure connections.	Open offer
Semrush	SEO and marketing platform for analysis and traffic growth.	Open offer
Make	Advanced visual automation for workflows and integrations.	Open offer
Hostinger	Web hosting and domains for fast website launch.	Open offer
Fiverr	Marketplace for freelancers and external specialists.	Open offer
Adobe	Creative tools for graphics, video, and digital content.	Open offer
Canva	Online design tool for graphics, presentations, and social media.	Open offer
Jasper	AI tool for marketing copy and content campaigns.	Open offer