Tender platform & analytics

AI tender analysis plus real time SEAP alerts: document understanding, requirement extraction, prequalification and company profile matching on a .NET modular monolith, with a TypeScript ingestion edge, RabbitMQ handoff and Redis caching.

TypeScript
Node.js
RabbitMQ
Redis
.NET
CQRS
Microsoft Agent Framework
LLM

Description

Achizito helps companies win Romanian public tenders by tracking notices published on SEAP and alerting users as soon as something relevant appears.

The product promise is simple and strict: real time alerts in under one second. If an alert is late, the customer loses bidding time.

Finding a tender is only the first step. A company must also read long tender documents and decide if it qualifies. This used to take about 3 days of manual work per tender. The platform now uses AI to understand the documents, extract the requirements, run the prequalification and match the tender with the company profile. Tender analysis now takes about 30 minutes instead of 3 days.

This engagement focused on keeping the ingestion edge separate from the core domain model so the team could move fast on source intake while the modular monolith stayed clean and predictable.

Key achievements:

  • Tender analysis from 3 days to 30 minutes with AI document understanding, requirement extraction, prequalification and company profile matching
  • Sub second alert flow from source update to alert dispatch
  • Node.js ingestion reuse from an existing project the team already had
  • Modular monolith boundaries preserved in the .NET core domains
  • RabbitMQ based event flow between ingestion and business domains
  • Redis based caching for LLM and repeated lookups
  • Single database for speed and consistency across the platform

Original context

The platform is a .NET modular monolith with Procedures, Documents, Requirements, Notifications, and Analytics.

Solution approach

SEAP public sourcesRabbitMQ QueueRedis CacheCore systemsDomain modulesTypeScript Ingestion Edge (Node.js).NET Modular MonolithProceduresDocumentsRequirementsNotificationsAnalytics

AI tender analysis

The AI pipeline runs inside the .NET core, next to the procedure, requirement and company data it needs. It is built with Microsoft Agent Framework.

Tender documents (SEAP)1. Document understanding2. Requirement extraction3. Prequalification4. Company profile matchingAlert with fit score

1. Document understanding

The Documents module reads the tender files: the data sheet, the technical specifications and the attachments. The AI turns long, unstructured documents into a clear summary of the procedure.

2. Requirement extraction

The Requirements module extracts what the contracting authority asks for as structured data: qualification criteria, required documents, guarantees and deadlines.

3. Prequalification

The platform checks the qualification criteria, such as turnover, similar past contracts, certifications and staff. The result is a clear go or no-go before the company spends time on the bid.

4. Company profile matching

The Companies module matches the extracted requirements with the company profile: activity codes, past contracts and financial data. Each tender gets a fit score, and the Notifications module uses it to decide which alerts to send.

Result: tender analysis that took about 3 days of manual reading now takes about 30 minutes.

Architecture decisions

1. Reuse the Node.js ingestion project

We found an existing Node.js ingestion project that already solved the source intake problem, so we reused it as the ingestion edge.

That let us focus on integration, module boundaries, and event flow instead of rebuilding source intake from scratch.

2. Keep the .NET modular monolith as the domain model

The core stays as one modular monolith.

Each domain owns its own rules and data, and the business logic stays in one place where the team can reason about it.

3. Use RabbitMQ for real time handoff

The ingestion edge sends real time work through RabbitMQ queues.

That gives the platform a clean boundary between intake and processing.

4. Use Redis for repeated reads

Redis is used to cache LLM-related data and repeated reads that do not need to hit the core every time.

That keeps the platform responsive while the core continues to own the business truth.

5. Single database on purpose

The platform keeps one shared database on purpose.

That gives the team faster development, simpler querying, and a consistent view across ingestion and core domains.

The modules still keep separate responsibilities in code. The shared database is only the practical persistence layer that lets the monolith stay simple to evolve.

6. Explicit division of responsibilities

ConcernOwner
Ingesting SEAP updates and normalizationTypeScript / Node.js
Queueing and real time handoffRabbitMQ
Subscriptions and business rules.NET
Market analytics.NET
AI extraction and eligibility.NET + Microsoft Agent Framework
Notification policy and delivery decisions.NET

The TypeScript ingestion edge owns intake behavior. The .NET core owns the domain model, analytics, and decisioning.

Requirements and domain interaction

The platform needed a few non-negotiable behaviors:

  • Alerts must be generated quickly enough to preserve bidding time.
  • Ingestion must stay separate from procurement rules.
  • Analytics must remain consistent with the same procedure data that drives alerts.
  • Notifications must be driven by domain behavior, not by raw source noise.
  • AI workflows must stay in the core where procedure, requirement, and notification context already exists.

The important point is that ingestion feeds the model, but does not absorb it.

Modular monolith boundaries

The core is split into clear subdomains with separate responsibilities:

  • Procedures - the main procurement lifecycle and state of a tender.
  • Documents - procedure files, attachments, and extracted content.
  • Requirements - matching and evaluation of what the procedure asks for.
  • Notifications - alert decisions and delivery triggers.
  • Companies - business entities and their identity in the platform.
  • Analytics - reporting, trends, and market intelligence.

These subdomains do not call each other directly for business changes. They interact through domain events, which keeps each responsibility narrow and makes the modular monolith easier to change safely.

Ingestion EdgeRabbitMQApplicationRedis CacheDomain modulesProceduresDocumentsRequirementsNotificationsCompaniesAnalytics

Results

OutcomeImpact
AI tender analysisFrom about 3 days of manual review to about 30 minutes per tender
Real time alertingIngestion remains optimized for low-latency source updates
Domain clarityCore business logic stays in explicit .NET bounded contexts
Coupling reductionIngestion and core interact through queues and shared domain contracts
MaintainabilityTypeScript ingestion can evolve independently from core domain rules
Platform resilienceDomain boundaries make failures easier to isolate and recover

Conclusions

This project delivered real-time procurement alerts and AI tender analysis for a tender platform, while improving domain boundaries instead of eroding them. The architecture balances ingestion speed, modular ownership, and long-term maintainability.

The next phase is controlled evolution: keep the modular monolith clean, keep the single database as the practical source of truth, and preserve sub-second user-facing alert behavior.