Requestador — AI Answers That Make Sense

Use Cases

The same control layer.
Eight different problems solved.

Real teams. Real problems. One control layer that made AI reliable in production.

E-Commerce

One Integration,
Unlimited Validators

A fast-growing e-commerce operation was scaling into new markets, adding carriers, and integrating more systems every quarter. But validation logic — the rules that check whether an address is real, a VAT number is valid, a shipment weight is within limits — was being rebuilt from scratch every single time, in every single system.

ARCHITECTURE

// Before: validation everywhere
Storefront  → own rules
Backoffice  → own rules
Warehouse   → own rules
Call center → own rules

// After: integrate once
Storefront  → Requestador → ERP
Backoffice  → Requestador → WMS
CSV Import  → Requestador → Orders
Call center → Requestador → CRM

// Add new validators → zero deploys

The Problem

Validation logic lived everywhere — and it was breaking everything

When a new carrier required a different address format, four teams had to coordinate a release. When a new market launched, developers rebuilt the same postal code checks they'd written twice already. Customers were getting through checkout with bad addresses and finding out at the warehouse. VAT numbers were passing the storefront but failing invoicing. The same broken data, over and over, from different angles.

Duplicate rules across storefront, ERP, warehouse, and backoffice — each slightly different

Address errors slipping through to the warehouse, causing failed deliveries and support backlogs

Carrier rule changes forced coordinated multi-system deployments across teams

Free-text return reasons made analytics meaningless and routing entirely manual

The Solution

Requestador became the single place where validation lives

Instead of rebuilding rules per system, the team integrated each application once to Requestador. From that point on, adding a new validator — a new carrier's weight limit, a new country's address format — meant configuring a single endpoint. No deployment. No cross-team coordination. Business teams started owning rules that used to require a developer ticket.

How it works

Checkout submits address to the validate_address endpoint. Requestador checks postal code against city, validates phone format, confirms carrier compatibility — and returns structured errors or a normalized result.

Same endpoint reused in backoffice order editing, call center entry, CSV bulk imports. The rules are central — every surface gets identical behavior without any extra code.

Return reasons are mapped through a catalog layer: "product didn't fit" → SIZE_ISSUE, "arrived damaged" → DAMAGE_TRANSIT. Analytics and routing automation become possible overnight.

Any System→Requestador→Validated Result→Continue Process

The Result

Validation stopped being a development task

The team stopped rebuilding the same logic. New validators were added in minutes by business teams, not developers. Delivery failures dropped. Support workload dropped. And when a new market launched, integration was a configuration task — not a sprint.

1Integration point for all validation

∞New validators without new code

0Deployments for rule changes

↓Delivery failures & support cost

Product Data – Pimcore

50,000 Products.
Hours, Not Months.

An e-commerce operator running Pimcore had a catalog problem. Tens of thousands of products — imported from suppliers, added over years — with inconsistent names, missing descriptions, and zero SEO structure. Manual enrichment was happening but it was never going to catch up.

ENRICHMENT PIPELINE

// Step 1: Classify product
"endpoint": "classify_group"
"output":   { "group": "DIY" }

// Step 2: Generate group-specific content
"endpoint": "generate_diy_content"
"output": {
  "product_name": "Power Drill 18V Compact",
  "short_desc":   "Lightweight cordless...",
  "seo_title":    "Buy 18V Compact Drill..."
}

The Problem

Content creation was a bottleneck that only got worse at scale

The catalog had grown faster than the team could enrich it. DIY products needed technical descriptions. Wine needed storytelling. Furniture needed dimensions and use-case language. Each category had its own logic — and every time that logic needed to change, a developer had to be involved.

Thousands of products with incomplete or inconsistent names and descriptions

Different product groups needed completely different content logic — impossible to generalize

Every prompt or logic change required a developer and a deployment cycle

AI outputs weren't structured enough to write back directly into Pimcore fields

The Solution

A Pimcore plugin turned AI into a controllable, configurable content engine

The team built a Pimcore plugin that connected directly to Requestador endpoints. Each action in Pimcore mapped to an endpoint that defined the prompt logic, expected output structure, and validation rules.

How it works

The classify_group endpoint determines what kind of product it is — DIY, Furniture, Wine, Electronics — based on raw input data.

A group-specific content endpoint generates a product name, short description, long description, and SEO content using prompts tailored to that category.

The catalog validation layer normalizes the AI output — fixing casing, enforcing character limits — before writing structured data back into Pimcore fields.

Pimcore Grid→Requestador→Private AI→Catalog Validation→Pimcore Fields

The Result

AI became an operational tool, not an experiment

What previously took weeks of manual copywriting was reduced to hours of automated processing. More importantly: the business team could now adjust prompt logic themselves. No tickets. No deployments. No waiting.

Hoursto enrich thousands of products

0Dev deploys for prompt changes

100%Business-owned prompt logic

SEOValidated output on every product

Banking & Finance

Six Systems.
One Source of Truth.

A mid-sized European bank had built its digital infrastructure piece by piece over a decade. Six systems. Six sets of validation rules. When a customer opened an account on mobile, the data looked valid. When it reached the compliance system three steps later — it didn't.

ONBOARDING VALIDATION

// Private AI normalizes input
"raw_address": "Main str. 12a, Zagreb"
"normalized":  "Main Street 12A, Zagreb"

// Rule-based final decision
"status":          "pass"
"audit_metadata": {
  "rule_version": "v4.2.1",
  "ai_confidence": 0.97,
  "data_residency": "on-premise"
}

The Problem

Validation inconsistency was creating compliance risk at every touchpoint

Each system had its own interpretation of what valid customer data looked like. A mobile onboarding form would accept an abbreviated street name. The core banking system would reject it two steps later, triggering a manual review queue.

Data accepted by mobile banking rejected later by compliance — creating manual review backlogs

Regulatory updates required coordinated releases across six independent systems

GDPR and banking supervision blocked any use of public AI services with customer data

The Solution

Requestador became the gateway — with a private AI model running entirely on-premise

All digital channels were routed through Requestador before data reached core banking or compliance systems. A private AI model, deployed inside the bank's own infrastructure, handled the interpretive work — normalizing addresses, extracting data from uploaded documents.

How it works

Customer submits onboarding data via any channel. All channels route to Requestador — no system talks directly to core banking anymore.

Where interpretation is needed — normalizing an address, reading a document — the private AI model processes the data on-premise.

Requestador applies rule-based final validation on the AI output, producing a full audit trail.

All Channels→Requestador→Private AI (on-prem)→Core Banking

The Result

The bank got AI and kept control — with zero data leaving its infrastructure

Onboarding inconsistencies dropped. The manual review queue shrank. Regulatory updates became single-system changes. And for the first time, the bank had a complete audit trail for every validation decision.

1Central place for all regulatory rules

0Customer bytes sent to public AI

FullAudit trail on every decision

AI Image Generation

From Design Bottleneck
to Automated Pipeline

A large e-commerce company launched product bundles constantly — starter kits, seasonal promotions, B2B clearance sets. Each bundle needed a custom visual: the right products composed together, the right background for the campaign type.

IMAGE PIPELINE

// Category-driven layout rules
"diy_products"    → "neutral technical bg"
"lifestyle_bundle" → "contextual scene bg"

// Output validation before publish
"resolution":  "1200x1200"  ✓
"brand_rules": "compliant"  ✓

The Problem

Marketing moved fast. Design couldn't keep up.

The commerce team could create a bundle in five minutes. Getting an image for it took hours — sometimes days. Designers were handling production assets for short-lived promotional bundles, work that was repetitive but couldn't be skipped.

Hours to days of designer time per bundle — campaigns delayed waiting for visuals

Inconsistent layouts, shadows, and positioning across different campaigns and designers

IP and branding concerns made public AI image services unusable

The Solution

Requestador turned bundle creation into an automatic visual pipeline

Requestador was deployed as the orchestration layer between the commerce system and a private AI image generation service. When a bundle was created, Requestador received the product composition data and automatically determined the correct layout, background style, and brand rules.

How it works

A bundle is created in the commerce system. Requestador receives the product list and determines layout rules.

The private AI image service generates a composed bundle image on-premise — consistent lighting, standardized spacing.

Requestador validates the output — resolution, aspect ratio — before returning it. Approved images are stored in DAM.

Bundle Created→Requestador→Private AI→Validated→DAM / Published

The Result

Image production became part of the operational workflow

Bundle image creation dropped from hours to minutes. Campaign launches accelerated. Visual consistency improved — not because designers were more careful, but because the rules were encoded. Design capacity was freed for creative work.

Minvs hours per bundle visual

100%Brand-consistent outputs

0Customer IP sent to public AI

Enterprise SaaS

Single-Tenant Complexity.
Clean Product Core.

An enterprise SaaS platform had a problem that every successful SaaS eventually faces: too many customers, each with slightly different requirements. One client needed a mandatory field others didn't. Another had country-specific validation rules.

SINGLE-TENANT VALIDATION

// Tenant-specific endpoint
"org_id":   "tenant_42"
"endpoint": "validate_import_record"

// External system mapping
"external_status": "DELIV_OK"  →  "internal_status": "Completed"

The Problem

Customization was accumulating as technical debt inside the product

The platform had grown through three approaches to tenant variation: hardcoded exceptions, configuration flags scattered through the codebase, and custom integration branches for large clients. Validation logic was particularly fragile: it touched every data entry point.

Tenant-specific validation hardcoded as conditional branches — the product was becoming unmaintainable

Import pipelines failing on inconsistent external formats — support costs growing with every new integration

Business rules changing faster than release cycles — customers waiting weeks for simple rule updates

The Solution

Validation moved out of the product and into a dedicated configurable layer

Requestador was introduced as the validation and decision layer between client input and the SaaS platform's business logic. Instead of encoding tenant-specific rules in code, each tenant got its own Requestador endpoints. The platform stayed stable — it called Requestador and received a consistent, structured response.

How it works

Client data enters the SaaS platform and is routed to tenant-specific Requestador endpoints.

Imports and external integrations pass through Requestador's mapping layer. ERP status code "DELIV_OK" becomes the platform's internal "Completed".

Configuration changes are validated before activation — preventing runtime failures.

Client Input→SaaS Platform→Requestador (per-tenant)→Business Logic

The Result

The product got cleaner while the platform got more flexible

Tenant-specific branches disappeared from the codebase. Release cycles shortened. Support costs from bad imports dropped. Business teams started managing validation rules themselves — the work that used to require a developer ticket now happened in a configuration interface.

0Tenant-specific code branches

0Deployments for rule changes

CleanProduct core maintained

Sales Agents (Email)

Email Orders In.
Structured Quotes Out.

A B2B sales team was still receiving a meaningful share of quote requests and repeat orders by email. Customers sent free-form messages, PDFs, spreadsheets, and screenshots with inconsistent product names, quantities, and references. Sales agents were manually translating each request into quote lines inside their sales system. Requestador was used to extract order intent, map requested items to the internal catalog, validate the result, and prepare a draft quote for human review before final confirmation.

ORDER-TO-QUOTE PIPELINE

// Step 1: Extract order intent
"endpoint": "extract_order_request"
"output": {
  "customer_reference": "ACME d.o.o.",
  "items": [
    { "input": "Dell 27 monitor", "qty": 20 },
    { "input": "docking station", "qty": 10 }
  ]
}
// Step 2: Match items to internal catalog
"endpoint": "map_order_lines"
"validation": ["sku_exists", "quantity_numeric"]
// Step 3: Generate review-ready quote draft
"output": { "matched_items": 3, "ambiguous_items": 1, "quote_status": "ready_for_review" }
// Agent validates → quote is finalized

The Problem

Manual email-to-quote processing was slowing the sales team down

The business had already invested in ecommerce and ERP workflows, but a significant part of inbound demand still came through email. Some customers preferred it. Some never changed their ordering habits. Others sent quote requests in whatever format was easiest for them. That left inside sales teams doing translation work by hand — interpreting product descriptions, matching them to internal SKUs, checking quantities, spotting missing details, and preparing quotes line by line. It was operationally expensive, error-prone, and hard to standardize.

Quote requests and orders arriving as unstructured emails and attachments

Product names, codes, pack sizes, and quantities expressed inconsistently

Agents manually translating customer intent into ERP or ecommerce quote lines

Customers still preferring email ordering, with no desire to force full channel migration

The Solution

Requestador turns inbound email into a controllable quote preparation workflow

Instead of using AI as a free-form assistant, the team used Requestador as the control layer between customer email and quote creation. Each stage of the process was mapped to a Requestador endpoint with defined prompt logic, expected output structure, and validation rules. When an email arrived, Requestador extracted the requested items, normalized the inputs, mapped them to internal catalog entries, validated the output, and returned a structured quote draft for agent review. Clear matches moved forward. Ambiguous lines stayed visible for human decision-making.

How it works

The extract_order_request endpoint parses the inbound email and identifies products, quantities, units, delivery references, and missing details from unstructured text or attachments.

The map_order_lines endpoint matches customer wording to internal catalog entries. It interprets informal product descriptions, old product names, or partial references and returns canonical SKUs where confidence is high enough.

The validation layer checks whether the output is usable: SKU exists, quantity is numeric, unit is allowed, and result matches required quote structure.

The quote draft endpoint returns review-ready structured output for the sales agent, with unmatched or low-confidence lines clearly flagged.

The agent reviews exceptions, confirms the result, and finalizes the quote in ERP, ecommerce backoffice, or downstream sales workflow.

Email Inbox→Requestador→Catalog Mapping→Validation Layer→Quote Draft→Agent Review

The Result

AI became a practical sales operations tool, not another automation experiment

Instead of starting from raw email every time, agents started from structured intent. Repetitive interpretation work was reduced, quote preparation became faster, and the team could continue supporting customers who preferred email without keeping the entire workflow manual. Most importantly, AI stayed under business control. Prompt logic, validation rules, and structured outputs were defined upfront — so the workflow was usable in production, not just impressive in a demo.

Minutesnot manual re-entry to prepare review-ready quote drafts

ControlledAI output with validation before agent review

Humanin the loop for exceptions and ambiguous matches

Emailstill supported without keeping the workflow fully manual

Catalog Structuring

Raw Catalog Data In.
Structured Categories and Products Out.

A company preparing to launch its online catalogue or ecommerce presence had a familiar problem: the products existed, but the catalog did not. Data was spread across ERP exports, supplier files, spreadsheets, and PDFs. Product names were inconsistent, descriptions were missing, attributes were incomplete, and there was no usable category structure for online browsing. Before anything could go live, the business needed to organize both the catalog hierarchy and the product data — and manual preparation would take months.

CATALOG STRUCTURING PIPELINE

// Step 1: Build / assign category structure
"endpoint": "classify_catalog_taxonomy"
"output": { "category": "Office Furniture", "subcategory": "Office Chairs", "product_group": "Ergonomic Chairs" }

// Step 2: Generate category-aware product content
"endpoint": "generate_product_fields"
"output": { "product_name": "Ergonomic Office Chair with Lumbar Support", "seo_title": "Ergonomic Office Chair | Adjustable Support" }

// Step 3: Extract and normalize attributes
"endpoint": "map_attribute_schema"
"validation": ["taxonomy_valid", "required_fields_present", "attribute_schema_valid"]
// → Category + product structure ready for PIM / ecommerce

The Problem

The business had products, but no usable online catalog structure

The source data was not designed for online presentation. ERP exports were technical. Supplier files were inconsistent. Product names varied, descriptions were often missing, and category logic was either too shallow or completely absent. Even where product groups existed internally, they were not suitable for customer-facing navigation or filtering. Before launching online, the business had to solve two problems at once: define a usable category structure for the catalog, and prepare each product to fit into it with the right content, attributes, and SEO fields. Manual preparation was possible — but far too slow.

No clean category and subcategory structure for online browsing

Products not consistently assigned to a usable taxonomy

Missing descriptions, inconsistent names, and incomplete attributes

Large manual effort required before catalogue or ecommerce launch

The Solution

Requestador turned catalog structuring into a controllable workflow

Instead of manually building the taxonomy and then enriching products one by one, the team used Requestador as the control layer for both catalog categorization and product structuring. Each stage was handled through defined endpoints: taxonomy classification, category assignment, product content generation, attribute mapping, and validation. Requestador did not just generate text. It helped create the actual online catalog structure by determining where products belonged, how categories should be organized, and which attributes and content logic applied to each part of the catalog.

How it works

The classify_catalog_taxonomy endpoint determines the best-fit category, subcategory, and product group for each product based on source data, naming patterns, attributes, and context.

The taxonomy logic can be aligned to the target online structure, not just copied from ERP or supplier groupings. Output is optimized for online navigation, filtering, and customer understanding.

The generate_product_fields endpoint creates category-aware product content, including naming logic, short and long descriptions, and SEO fields based on the assigned category.

The map_attribute_schema endpoint extracts and normalizes product attributes into the correct structure for that category or group, so different types of products can follow different field logic.

The validation layer checks that both taxonomy and product data are usable: required fields are present, attribute structures are valid, naming follows business rules, and the result is ready for import into Pimcore, PIM, or ecommerce.

Raw Product Data→Requestador→Taxonomy Classification→Category Assignment→Content Generation→Attribute Mapping→Validation Layer→Structured Catalog Output

The Result

The online catalog was structured before launch — not cleaned up afterward

What would normally require a long manual catalog preparation phase became a repeatable workflow. The business could define its category structure, assign products consistently, generate product data aligned to that structure, and prepare the catalog for launch much faster. Most importantly, the taxonomy and content logic stayed under business control. The team could refine category rules, attribute schemas, and content patterns over time without rebuilding the process from scratch.

Categories+Productsstructured in one workflow

Online-readytaxonomy for browsing and filtering

Business-controlledlogic for content and catalog structure

Readyfor import into PIM or ecommerce

EU AI Act Compliance

EU AI Act Readiness

Turn AI into controlled, auditable systems and take the first step toward compliance. The EU AI Act sets requirements for companies developing or using AI in the EU — especially for high-risk systems. Companies must ensure their AI outputs are reliable and accurate, traceable and auditable, governed and controlled, and safe for real-world decision-making. Requestador is a control layer that helps you get there.

COMPLIANCE AUDIT TRAIL

// Every AI call — structured and logged
"endpoint":       "assess_loan_eligibility"
"input_hash":     "sha256:a3f9..."
"model_used":     "private-llm-v2"
"rule_version":   "v3.1.0"
"ai_output":      { "risk_band": "LOW" }
"validation":     "passed"
"human_reviewed": true
"decision":       "approved"
"data_residency": "on-premise"

// Exportable for regulatory audit

The Requirements

What the EU AI Act requires from companies using AI

Under the EU AI Act, companies using AI in production may need to ensure AI outputs are accurate and reliable, maintain audit trails and logging of AI decisions, implement risk management and governance processes, provide transparency into how AI systems operate, and enable human oversight of automated decisions. These requirements are especially important for high-risk AI systems — those used in hiring, finance, healthcare, and other critical domains.

Ensure AI outputs are accurate, reliable, and consistent across systems

Maintain audit trails and logging of every AI decision made in production

Implement governance and risk management over all AI behavior

Enable human oversight of automated decisions in high-risk workflows

How Requestador Helps

A control layer that makes AI structured, predictable, and auditable

Requestador is not a complete EU AI Act compliance solution — companies still need legal frameworks, risk classification, technical documentation, and human decision-making processes. But it is a strong technical foundation within a broader compliance strategy, particularly for companies already using AI in APIs and workflows.

What Requestador provides

Structured AI outputs. AI responses are validated and formatted before they reach downstream systems. This supports consistency and makes outputs easier to audit and review under EU AI Act requirements.

Improved accuracy and reduced AI risk. Validation rules ensure responses meet predefined criteria — reducing hallucinations and incorrect decisions, which is critical for high-risk AI systems.

AI governance and control. Prompts and logic are centralized and reusable, creating a single point of control over AI behavior and supporting governance requirements in the EU AI Act.

Auditability and traceability. AI interactions are standardized and tracked as part of structured workflows — supporting logging, traceability, and internal audits required for EU AI Act compliance.

AI Request→Requestador→Validation + Rules→Structured Output→Audit Log→Human Oversight

The Starting Point

A practical first step toward EU AI Act readiness

For many companies, EU AI Act compliance starts with gaining control over AI outputs. Requestador helps teams standardize AI usage across systems, reduce operational and compliance risk, prepare AI systems for auditing and governance, and build more reliable AI workflows in production. It transforms AI from unpredictable outputs into structured, controlled workflows — making it a strong starting point for companies working toward compliance, especially those using AI in production environments.

StructuredValidated AI outputs before any system acts on them

CentralizedSingle point of control over all AI prompt logic

TraceableStandardized interactions ready for audit and governance

Lower riskReduced hallucinations and incorrect AI decisions

AI AnswersThat Make Sense

Your AIControl Layer

Infrastructure Built forProduction AI

Centralized Prompt Hub

Smart Validation Engine

Catalog Mapping

Auto-Retry & Refinement

Single-Tenant Access Control

Private AI Compatible

Three Steps toReliable AI

Define Prompts

Validate & Transform

Receive Clean Data

The same control layer.Eight different problems solved.

One Integration,Unlimited Validators

Validation logic lived everywhere — and it was breaking everything

Requestador became the single place where validation lives

How it works

Validation stopped being a development task

50,000 Products.Hours, Not Months.

Content creation was a bottleneck that only got worse at scale

A Pimcore plugin turned AI into a controllable, configurable content engine

How it works

AI became an operational tool, not an experiment

Six Systems.One Source of Truth.

Validation inconsistency was creating compliance risk at every touchpoint

Requestador became the gateway — with a private AI model running entirely on-premise

How it works

The bank got AI and kept control — with zero data leaving its infrastructure

From Design Bottleneckto Automated Pipeline

Marketing moved fast. Design couldn't keep up.

Requestador turned bundle creation into an automatic visual pipeline

How it works

Image production became part of the operational workflow

Single-Tenant Complexity.Clean Product Core.

Customization was accumulating as technical debt inside the product

Validation moved out of the product and into a dedicated configurable layer

How it works

The product got cleaner while the platform got more flexible

Email Orders In.Structured Quotes Out.

Manual email-to-quote processing was slowing the sales team down

Requestador turns inbound email into a controllable quote preparation workflow

How it works

AI became a practical sales operations tool, not another automation experiment

Raw Catalog Data In.Structured Categories and Products Out.

The business had products, but no usable online catalog structure

Requestador turned catalog structuring into a controllable workflow

How it works

The online catalog was structured before launch — not cleaned up afterward

EU AI Act Readiness

What the EU AI Act requires from companies using AI

A control layer that makes AI structured, predictable, and auditable

What Requestador provides

A practical first step toward EU AI Act readiness

Built forAI-Forward Teams

Compliance & Legal Teams

SaaS Companies

E-commerce Teams

Product Managers

Banking & Finance

Developers

AI Engineers

Ready for Reliable AI?

Contact

AI Answers
That Make Sense

Your AI
Control Layer

Infrastructure Built for
Production AI

Three Steps to
Reliable AI

The same control layer.
Eight different problems solved.

One Integration,
Unlimited Validators

50,000 Products.
Hours, Not Months.

Six Systems.
One Source of Truth.

From Design Bottleneck
to Automated Pipeline

Single-Tenant Complexity.
Clean Product Core.

Email Orders In.
Structured Quotes Out.

Raw Catalog Data In.
Structured Categories and Products Out.

Built for
AI-Forward Teams