
Building Innvora: From Inventory Events to Replenishment Intelligence with AWS
Built Innvora at First Commit WeMakeDevs x AWS hackathon, an event-driven inventory operations platform using AWS Lambda, SQS, DynamoDB, OpenSearch, API Gateway, VPC, IAM, and AWS CDK to help retailers and warehouse teams turn inventory changes into actionable replenishment decisions.
Building Innvora: From Inventory Events to Replenishment Intelligence with AWS
Inventory problems rarely begin with a single dramatic failure.
They usually begin with small signals.
A product sells faster than expected.
A warehouse runs lower than another location.
A supplier takes longer to deliver.
A store has too much of one product and too little of another.
For an independent retailer or a growing D2C business operating across multiple locations, keeping track of these signals manually becomes increasingly difficult.
That is the problem we wanted to address with Innvora.
What is Innvora?
Innvora is a real-time inventory operations platform designed for:
- independent store owners
- warehouse operations leads
- multi-channel D2C managers
The goal is simple:
Know what you have. Know what needs action.
Instead of treating inventory as a static table, Innvora treats inventory changes as operational events.
Sales, restocks, returns, adjustments, and transfers can move through the system as events. Those events update the current inventory state, become part of the historical event record, and feed replenishment decisions.
The result is a control center where an operations team can see:
- inventory health
- stock availability
- fulfillment hub status
- critical inventory
- reorder-soon items
- overstock
- historical activity
- replenishment recommendations
Why inventory needs an event-driven architecture
A traditional inventory application can start with a simple CRUD model:
User
↓
API
↓
Database
That works for basic applications.
But inventory operations are naturally event-driven.
A sale is an event.
A restock is an event.
A warehouse transfer is an event.
A return is an event.
So we designed Innvora around this flow:
Inventory Event ↓API Gateway ↓Lambda ↓SQS ↓Inventory Processor ↓DynamoDB ↓OpenSearch ↓Replenishment IntelligenceThis separation means the user-facing API does not have to perform every downstream operation synchronously.
For example, when a sale occurs, the event can be accepted by the API and placed on SQS. The processor then updates the inventory state and indexes the event for historical search.
Building the backend with AWS
We used AWS as the core of the backend.
Amazon API Gateway
API Gateway provides the public HTTP interface for the application.
Endpoints expose operations such as:
GET /inventoryGET /inventory/healthGET /reordersGET /inventory/searchPOST /inventory/eventsThis gives the frontend a single API boundary while keeping the underlying AWS services private.
AWS Lambda
Lambda powers the API handlers and the asynchronous inventory-event processor.
We separated responsibilities into different functions so that inventory ingestion, processing, search, and replenishment logic remain independently manageable.
Amazon SQS
SQS is the bridge between receiving an inventory event and actually processing it.
This was one of the most important architectural decisions in the project.
Instead of:
POST event ↓update everything ↓return responsewe use:
POST event ↓SQS ↓processorThis decoupling makes the system more resilient and gives us a foundation for higher event volumes.
We also configured a dead-letter queue so failed messages do not disappear silently.
DynamoDB as the operational inventory store
DynamoDB stores the current inventory state.
Our inventory records are organized around product and fulfillment location, using keys such as:
PK = LOCATION#<locationId>SK = PRODUCT#<productId>This reflects a common operational question:
“What inventory do I have at this location?”
The inventory state includes information such as:
- quantity
- reserved quantity
- available quantity
- reorder point
- safety stock
- last updated timestamp
This makes DynamoDB the operational source of truth for the current inventory state.
OpenSearch for historical inventory events
Current inventory and historical inventory are different problems.
DynamoDB is useful for:
“What is the current stock?”
OpenSearch is useful for:
“Show me inventory events for this SKU.”
Every processed inventory event can therefore become part of a searchable historical stream.
The search experience supports filters such as:
- SKU
- product ID
- location
- event type
- date range
- free-text queries
This allows an operations user to move from the current state into the history behind that state.
Replenishment intelligence
We intentionally kept the first version of Innvora explainable.
The current replenishment engine is deterministic rather than an LLM-based decision system.
It considers:
Available Stock+Average Daily Demand+Supplier Lead Time+Safety Stock+Forecast BufferFrom these inputs, it calculates a reorder point, remaining stock coverage, recommended quantity, and urgency.
The result can classify inventory as:
- CRITICAL
- REORDER_SOON
- HEALTHY
- OVERSTOCKED
For example, a product with low available stock and significant supplier lead time can move into a critical state before a stockout happens.
This also makes the recommendation explainable to an operations user.
Instead of simply saying:
“AI says reorder this.”
Innvora can explain why the recommendation exists.
Designing for real-world users
Different users experience the inventory problem differently.
Independent store owners
A store owner may not want to interpret a complicated inventory system.
They need to know:
Which products need my attention today?
Innvora turns the inventory state into clear operational categories and recommendations.
Warehouse operations leads
A warehouse manager needs visibility across locations.
Innvora provides fulfillment-hub context so teams can compare inventory health across locations instead of looking at isolated spreadsheets.
Multi-channel D2C operators
D2C teams often have inventory distributed across multiple locations and channels.
For them, the challenge is not just stock level.
It is timing.
When should inventory be replenished?
How much should be ordered?
Where is inventory under pressure?
Those are the operational questions Innvora is designed to surface.
Infrastructure as code with AWS CDK
We used AWS CDK with TypeScript to provision the infrastructure.
This allowed us to keep infrastructure definitions alongside the application code.
The CDK stack provisions and connects resources including:
- Amazon VPC
- Lambda functions
- API Gateway
- DynamoDB
- SQS and DLQ
- OpenSearch
- IAM roles and policies
- CloudWatch logging
This became particularly useful when debugging deployment issues because we could reproduce the entire infrastructure from code instead of relying on undocumented console configuration.
Learned while deploying
The most valuable part of the project was not simply getting the first API response.
It was understanding how the services interact.
We encountered several real deployment challenges.
One issue involved OpenSearch networking: the subnet configuration had to match the domain's zone-awareness configuration.
Another involved CloudFormation dependency resolution. An OpenSearch access-policy configuration accidentally created a dependency back to the same OpenSearch resource, resulting in a circular dependency during stack creation.
We also had to reason carefully about IAM identity policies versus resource-based access policies and how those references affect the CloudFormation dependency graph.
These issues were frustrating during development, but they also forced us to understand the infrastructure at a much deeper level.
What worked particularly well
Several AWS services mapped extremely well to the problem.
Lambda gave us serverless compute.
SQS gave us asynchronous event processing.
DynamoDB gave us a scalable operational data store.
OpenSearch gave us a dedicated historical search layer.
API Gateway provided a clean HTTP boundary.
CDK gave us reproducible infrastructure.
CloudWatch gave us operational visibility while debugging.
Together, these services let us move from a frontend prototype toward a real event-driven system.
What is next for Innvora?
The current system establishes the operational foundation.
The next layer is predictive intelligence.
That could include:
- demand forecasting
- seasonal demand patterns
- supplier reliability signals
- automated purchase-order workflows
- bulk product onboarding
- smarter cross-location transfers
- role-based access
- deeper anomaly detection
The important architectural decision is that predictive models do not have to replace the existing replenishment engine.
They can feed better demand estimates into it.
That gives us a path from:
Historical Inventory Events ↓Demand Forecast ↓Replenishment Engine ↓Actionable RecommendationClosing
Innvora started from a simple observation:
Inventory is not just a number. It is a stream of operational signals.
By combining API Gateway, Lambda, SQS, DynamoDB, OpenSearch, VPC, IAM, CloudWatch, and infrastructure-as-code with AWS CDK, we built a system that turns those signals into an operational view of what is happening and what needs attention.
The current version is a hackathon implementation, but the architecture gives us a foundation to continue building toward predictive inventory operations.
Innvora — know what you have. Know what needs action.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article