TechOvelpo

Case study, B2B procurement

Krayuv: Building a B2B Procurement and Auction Platform

A procurement platform has to be fair to suppliers and auditable for buyers. This is how we designed Krayuv around those two requirements, and what we would do differently.

requisition to payment
Source-to-payrequisition to payment
access control
Role-basedaccess control
launch year
2025launch year
RFQ evaluation
Two-envelopeRFQ evaluation
bids, hidden until the buyer unlocks them
Sealedbids, hidden until the buyer unlocks them
auction formats
Reverse and forwardauction formats

The problem

In most organisations, buying is held together by email threads and spreadsheets. A requisition waits in someone's inbox, quotes arrive in three different formats, the vendor list is out of date, and invoices are checked against orders by hand. Nobody can say with confidence where a purchase stands or why a supplier was chosen.

Krayuv is our answer to that. It is a B2B procurement platform covering the source-to-pay cycle: sourcing, RFQs, auctions, vendor management, purchasing and payment workflows. Krayuv is a product of Fensso Tech LLP, TechOvelpo's parent company, and it was built by the same engineers who take on client work. We can describe it in detail because it is ours.

The core engineering problem was not "build forms for purchase orders". It was to make competitive bidding trustworthy. A supplier who loses an auction needs to believe the process was fair. A buyer who awards a contract needs to be able to show an auditor why. Both beliefs rest on how the system handles timing, secrecy and records.

Constraints

  • Fairness is a product requirement. No participant, including the buyer's own staff, should see a sealed quotation before the buyer deliberately opens it after the deadline.
  • Several buying methods, one platform. Reverse auctions, forward auctions, RFQs and two-envelope RFQs behave differently, but buyers expect one vendor list and one set of reports across all of them.
  • Real-time behaviour. During a live auction, bids must reach every participant quickly and consistently.
  • Access must follow the organisation. Buyers, approvers, evaluators and suppliers each see different things, and the rules differ by role.
  • A small team shipping a product. The platform had to be maintainable by a compact group of engineers, which pushed us toward managed infrastructure and one language across the stack.

Options considered

We weighed three decisions that shaped everything else.

Decision Options What we chose and why
Data store Relational database, or a document database with real-time sync Google Firebase Firestore. Live auctions and bid tracking benefit from real-time synchronisation, and managed hosting kept operations light. The cost is that cross-document reporting needs deliberate design.
Language Separate languages for client and server, or TypeScript on the front end with Node.js behind it React 18 with TypeScript on the front end and Node.js with Express.js 5 behind it, so one team can work across both sides.
Secrecy of bids Hide bids with UI rules only, or enforce it on the server Server-enforced. Quotations stay encrypted and hidden until the buyer unlocks them after the deadline. A UI-only rule is one bug away from a leak.

We did not choose the document database because it is fashionable. We chose it because the auction screen is the part of the product where latency and consistency are most visible to users, and because real-time listeners are built in. If the product had been mainly back-office reporting, a relational database would have been the stronger default.

Architecture

The system is a conventional three-tier design with the real-time concerns pushed to the data layer.

Buyers, evaluators, suppliers (browser)
        |  React 18 + TypeScript
        v
Express.js 5 API (Node.js)  <-- JWT authentication, role-based access control
        |
        v
Google Firebase Firestore   <-- events, quotations, vendors, audit records
        |
Hosted on Google Cloud Platform
Layer Responsibility
Front end Event creation, vendor onboarding, live auction screens, bid comparison, reports
API Authentication, authorisation by role, business rules, deadline enforcement, unlocking of sealed bids
Data Procurement events, quotations, vendor records, scoring and ranking inputs
Infrastructure Google Cloud Platform hosting, encrypted data transmission

Notable engineering decisions

Sealed quotations are a server concern

Every quotation is stored encrypted and is not readable until the buyer explicitly unlocks it after the submission deadline. The API, not the interface, decides who may read what and when. That means the same rule holds whether a request comes from the web app or from anything else that can reach the API.

Two-envelope evaluation as a state machine

In a two-envelope RFQ, technical proposals are evaluated and scored before commercial bids are revealed, so price cannot bias the technical assessment. We modelled this as explicit stages: submission, technical evaluation, commercial opening. Each event moves forward only when the previous stage is closed. Treating it as a state machine rather than a set of flags made invalid transitions impossible to express, and it gave us a natural place to write audit records.

Vendor qualification before commercial evaluation

The platform checks vendors against the criteria set in the RFQ, such as years in business, certifications, revenue thresholds and geographic coverage. Vendors who miss the minimums are flagged before commercial evaluation. This turns a manual screening step into a rule the buyer defines once.

Comparison and ranking built for buyers

Buyers get item-by-item comparison across participating vendors, automatic identification of the lowest quotes, bid ranking with weighted scoring, savings calculations and Excel export. The export matters more than it sounds: procurement teams keep offline records, and a platform that traps their data does not get adopted.

Role-based access from the start

JWT authentication and role-based access control were designed into the API on day one. Retrofitting roles onto a system that assumed everyone could see everything is far harder than starting with the rules.

What was hard, and what we would do differently

Auctions expose every timing assumption. The hard part of a live auction is not rendering a leaderboard. It is deciding what happens at the boundary: a bid arriving as the clock expires, a participant whose browser clock is wrong, a reconnect mid-event. The lesson is to make the server the only authority on time and to write the closing rules down before writing the code. Client clocks should only be used for display.

Real-time sync does not replace reporting design. Document databases make live views easy and cross-event analysis harder. If we started again, we would define the reporting questions earlier, such as savings by category or vendor performance over time, and shape the stored data around them instead of adding aggregation later.

Audit trails are cheaper to design in than to add. Procurement is a domain where "who did what, and when" is asked after the fact. We would treat the audit record as a first-class output of every state change from the first sprint.

Configurability has a cost. Buyers want rules that match their own approval structure. Every option is another path to test. We would keep the default workflow strict and simple, and add configuration only when a real buyer needs it.

What this means if you are building something similar

If your product involves competitive processes, approvals or any workflow where trust depends on the record, the decisions above carry over. Decide early where secrecy and timing are enforced, model multi-stage processes explicitly, and design reporting before the data model is frozen.

The stack here is ordinary on purpose. A team comfortable with React, TypeScript and Node.js can build and maintain this kind of platform. If you need that capacity, our full-stack developers work with exactly this combination, and a dedicated development team suits a product that will keep growing after launch. For a platform with a defined first release, a fixed-price project may fit better.

You can see the finished product at krayuv.com. To talk through a platform of your own, get in touch, or read about the sister product Facilis CRM.