
Vyapio : Less to Remember, More Room to Grow
Vyapio is more than a digital shop-management tool—it is a practical, voice-first companion for neighbourhood businesses. By combining multilingual voice interaction, accurate financial logic, offline support, AI-assisted insights, and AWS-powered infrastructure, Vyapio helps shopkeepers manage everyday operations with greater simplicity, accuracy, and confidence.
Vyapio: A Voice-First Shop Management Platform
A neighbourhood kirana shop often runs on memory.
The shopkeeper remembers which customer regularly buys rice, who still owes money from last week, which products are running low, and who has already made a payment.
But managing all of this information while simultaneously serving customers is difficult.
Writing everything down takes time. Searching through notebooks takes even more. And when something is forgotten, it can directly affect the shop's revenue.
This was the problem we wanted to solve with Vyapio.

A little shop. A lot to remember.
Vyapio is a voice-first shop management platform designed specifically for Indian neighbourhood shops. It gives the shop a digital memory by bringing customers, sales, payments, inventory, orders, reminders, and business insights into one workspace.
The shopkeeper can interact with the system naturally through voice, including Hindi, English, or a combination of both.
The Problem: A Shopkeeper Has Too Much to Remember
Consider a typical interaction:
"Priya ko 2 kilo chawal aur 1 liter doodh chahiye, 300 diya, baaki udhaar."
The shopkeeper should not have to manually:
- Find Priya.
- Find rice.
- Find milk.
- Enter quantities.
- Calculate the total.
- Update inventory.
- Record the payment.
- Calculate the remaining balance.
- Set the due information.
Vyapio is designed to turn that single spoken sentence into a structured transaction.
The system identifies the customer, matches the products against the shop's catalogue, calculates the prices, updates inventory, records the payment, creates the remaining debt, and presents the complete transaction for confirmation.
Only after the shopkeeper confirms does the transaction get saved.
How Vyapio Works
Vyapio connects natural voice interaction with customer records, inventory, payments, and AWS-powered backend services.
The overall journey is:
Speak → Transcribe → Extract → Resolve → Price → Draft → Confirm → Write
The architecture below shows how the voice-to-sale workflow connects with the AWS backend, data model, key features, and system safeguards.
[INSERT VYAPIO FLOWCHART + AWS ARCHITECTURE IMAGE HERE]
The image provides a high-level overview of the complete system, while the sections below explain each part in detail.

The Core Principle: Never Report Something That Did Not Happen
One of the most important design principles in Vyapio is:
Never report something that did not happen.
This principle influences almost every part of the system.
For example, a reminder that was recorded but never delivered must not be shown as "sent".
Similarly, an AI assistant should never invent a balance or stock quantity.
A sale's outstanding amount is frozen at the time of the sale for historical accounting, while current balances are resolved from debt records.
Products that are unavailable are explicitly shown as NOTAVAILABLE instead of silently disappearing from a transaction draft.
Money is stored as integer paise instead of floating-point values to avoid rounding errors in financial records.
The AI assistant also answers only from the shop's own records. If the required information does not exist, the system says so instead of inventing an answer.
Voice-First Sales
Voice is one of the defining features of Vyapio.
The voice-to-sale pipeline consists of several stages.
1. Transcript
The system first converts speech into text.
The default voice path uses the browser's Web Speech API. Amazon Transcribe is also integrated into the backend for server-side speech recognition.
2. Extract
The spoken sentence is converted into structured information:
- Customer
- Products
- Quantities
- Payment amount
- Payment-related information
3. Resolve
The system matches the extracted customer against the shop's customer records and the products against its catalogue.
Product aliases allow different expressions such as:
- chawal
- rice
- चावल
to resolve to the same product.
Customer matching also supports romanisation and phonetic matching, allowing names spoken or written in different scripts to resolve to the same person.
4. Price
Product selling prices are retrieved from the shop's records.
Line totals and the complete transaction total are calculated using deterministic code.
Money calculations are performed in paise rather than floating-point values.
5. Draft
Before anything is saved, the shopkeeper sees the complete transaction.
Unavailable products are shown explicitly instead of being silently dropped.
6. Confirm
The shopkeeper explicitly confirms the transaction.
The backend then performs one atomic write covering the relevant sale, inventory, payment, balance, and debt changes.
This prevents the system from partially applying a transaction.
Multi-Language and Offline Support
Vyapio is designed specifically for the Indian neighbourhood-shop environment.
The interface supports seven Indian languages with English fallback.
The application also includes a custom internationalisation layer.
Another important requirement is unreliable connectivity.
Vyapio includes an offline queue.
When a shopkeeper records a write while offline, the operation is queued locally and replayed when connectivity returns.
The goal is simple: a temporary loss of internet connectivity should not stop the shop from operating.
What Vyapio Manages
The platform brings several important areas of shop management together in one system.
Customers
The customer system maintains:
- Customer identity
- Contact information
- Purchase history
- Outstanding balances
- Total spending
- QR identification
Inventory
Inventory tracks:
- Products
- Stock quantity
- Selling price
- Cost price
- Reorder level
- Supplier
- Stock movements
Stock status is calculated as:
- In Stock
- Low Stock
- Out of Stock
Payments
Payments track:
- Money received
- Payment method
- Outstanding amounts
- Debt commitments
- Due dates
- Settlement status
Orders
Pickup orders can be recorded and tracked throughout their lifecycle.
Shop Memory
The shopkeeper can ask questions about the shop's own records instead of manually navigating through multiple screens.

The AI Shop Assistant
The AI layer is intentionally designed with clear boundaries.
A key architectural decision is:
No model is ever asked for a number.
Financial and inventory numbers need to be correct, not merely plausible.
Therefore, values such as:
- Sales totals
- Customer balances
- Stock quantities
- Inventory values
- Days remaining
are calculated using deterministic application logic.
AI is used downstream to make structured information easier to understand.
For example, a calculated value such as:
daysRemaining: 2.2 can be transformed into a natural-language insight such as:
"Cooking Oil may run out in about 2 days."
If the AI service is unavailable, the application can still render the underlying information.
A Safe AI Agent Architecture
The AI assistant follows a deliberate separation between planning and execution.
There are two agent endpoints:
/agent/run and
/agent/confirm The first endpoint can plan and retrieve information and write an audit record.
The second endpoint performs the actual execution.
The model cannot directly reach the confirmation endpoint.
This creates a clear human approval boundary.
In other words:
AI can suggest.
The human confirms.
The application executes.
Nothing is sent or committed simply because an AI model generated a response.
Shop Memory
Vyapio also includes a retrieval-based "Shop Memory" capability.
The assistant can answer questions using the shop's own records.
For example:
"Who owes me more than ₹500 and is overdue?"
The system retrieves the relevant shop records and presents the result.
The important constraint is that the assistant does not use general knowledge to manufacture shop-specific answers.
If there is no evidence in the shop's records, it says so.
AWS Architecture
Vyapio is built as a TypeScript monorepo with three workspaces:
-
frontend
-
backend
-
infrastructure
The frontend uses:
- React 19
- TypeScript
- Vite
- Tailwind CSS v4
- React Router
- Framer Motion
- Lucide
The backend uses:
- Node.js 22
- TypeScript
- Zod
- esbuild
- AWS SDK v3
The infrastructure is defined using AWS CDK v2.
The project uses eight CDK stacks and provisions 58 resources.

AWS Services Used
Amazon DynamoDB
DynamoDB is the primary database.
Vyapio uses a single-table design containing the shop's different entity types.
These include:
- Vendor
- Customer
- Product
- Transaction
- Payment
- Commitment
- Order
- InventoryEvent
- Notification
- PendingSignup
Two secondary indexes support time-based listings and customer-specific access patterns.
For example, today's sales and overdue debts can be retrieved using range queries instead of scanning the entire table.
Amazon Cognito
Amazon Cognito handles authentication-related functionality such as:
- Shopkeeper accounts
- Customer accounts
- Email verification
- Password reset
Tenant isolation is also designed structurally.
The
vendorId is derived from the authenticated session rather than being accepted from the request body.This prevents one shop from addressing another shop's data partition.
AWS Lambda
The backend API runs through a Lambda function packaged as a container image.
The application also uses a custom router so that the same backend code can run as:
- A Lambda handler
- A local HTTP server
This makes local development easier while keeping the production architecture serverless.
Amazon API Gateway
API Gateway provides the public HTTPS endpoint for the backend and handles routing and CORS.
The API routes requests to Lambda.
Amazon S3
S3 is used for object storage, including:
- Voice recordings
- Uploaded supplier invoices
- Receipt images
Amazon EventBridge
EventBridge handles business events such as:
- Sale recorded
- Payment received
- Stock becoming low
This allows business events to remain separate from the primary transaction workflow.
Amazon SQS
SQS provides a dead-letter queue for events that cannot be processed successfully.
This helps prevent failed event processing from silently disappearing.
Amazon SNS
SNS provides notification fan-out for notification workflows.
Amazon Bedrock
Amazon Bedrock is used as the optional downstream AI layer.
The architecture includes the Bedrock integration and IAM wiring.
However, the application is designed to remain functional even when Bedrock is unavailable.
This is an important design choice because core business operations should not depend on an AI model being available.
Amazon Transcribe
Amazon Transcribe is integrated into the system for server-side speech recognition.
The browser's Web Speech API provides the default voice path.
Amazon Textract
Textract is integrated for reading printed supplier invoices.
This can help convert supplier paperwork into structured inventory information.
Amazon CloudWatch
CloudWatch Logs provides structured request logging with a request ID on every log line.
This makes debugging and tracing backend requests easier.
Amazon ECR
ECR stores the container image used by the Lambda deployment.
Infrastructure as Code with AWS CDK
One of the architectural goals was to avoid manually configuring AWS resources.
The infrastructure is defined using AWS CDK v2.
The eight stacks include:
- Database
- Cognito
- Storage
- Events
- AI
- Lambda
- API
- Frontend
The infrastructure provisions 58 resources automatically.
The stacks are also separated according to their expected lifetime.
State-holding infrastructure such as the database, Cognito, and storage changes less frequently, while Lambda and API components can change more frequently alongside application code.
Why Lambda as a Container Image?
Instead of deploying Lambda as a traditional ZIP package, Vyapio uses a container image.
The build runs TypeScript compilation inside the image.
esbuild then bundles the backend into a single tree-shaken file.
This means the deployment artifact contains the compiled application rather than shipping the entire
node_modules directory.The goal is to keep the Lambda deployment efficient while maintaining a reproducible build.
Security and Least Privilege
Security was considered at the infrastructure level rather than only at the application level.
The Lambda function receives only the permissions required for its resources.
For example, it can read and write its own DynamoDB table and S3 bucket but does not have permission to create or delete those resources.
Permissions for services such as Bedrock, Transcribe, and Textract are granted only when their corresponding features are enabled.
This follows a least-privilege approach.
Data Model
The application's data model is centered around a shop or
Vendor .Each record carries the shop's
vendorId .The major relationships include:
Vendor → Customers
Vendor → Products
Vendor → Transactions
Vendor → Payments
Vendor → Commitments
Vendor → Orders
Vendor → Notifications
Transactions contain embedded line items.
Transactions can create commitments representing outstanding debt.
Payments can settle commitments.
Inventory events record stock movements.
This structure allows the system to maintain a connected history of what happened in the shop.
Why One DynamoDB Table?
Vyapio uses a single-table DynamoDB design.
Ten entity types live within the same table.
The records are keyed so that the data needed by a screen can often be retrieved from one partition.
Two secondary indexes support additional access patterns.
Sort keys carry timestamps or due dates, allowing queries such as:
- Today's sales
- Overdue debts
- Customer-specific records
to be handled as range queries instead of full table scans.
Tenant isolation is structural rather than simply relying on application-level filtering.
Derived Data Instead of Duplicated Data
Not everything is stored as a separate database field.
Some values are deliberately calculated when they are needed.
For example:
Stock status
is derived from:
stock + reorderLevel Stock value
is calculated as:
stock × costPrice Sales velocity
is calculated from inventory events.
Current outstanding amount
is resolved through commitment records rather than relying only on the frozen outstanding value stored on an old transaction.
This reduces the risk of duplicated values becoming inconsistent.
Financial Data Integrity
Financial data requires special care.
Vyapio stores money as integer paise instead of floating-point numbers.
The backend also uses schema validation and arithmetic refinements to prevent malformed financial data from being constructed.
One of the test guarantees is:
paid + outstanding = total A sale that violates this relationship cannot be constructed.
Testing
Vyapio currently has 429 automated tests:
- 289 backend tests
- 140 frontend tests
The project also runs:
- Type checking
- Linting
- Build verification
The test suite covers important business guarantees such as:
- Financial calculations
- Multi-language voice parsing
- Customer matching
- Inventory behaviour
- Tenant isolation
- Idempotency
- Delivery status honesty
An important testing practice used in the project is temporarily reverting a fix and confirming that the new test fails.
This helps ensure that tests genuinely protect the intended behaviour rather than simply passing without validating the underlying logic.
Local Development Without AWS Credentials
The local development environment mirrors the production interfaces.
When AWS credentials are unavailable, local adapters can replace AWS services:
- JSON files can represent DynamoDB
- Local JWTs can represent Cognito
- The local filesystem can represent S3
The application uses the same interfaces in both environments.
This allows the project to run on a developer's laptop without requiring a complete AWS environment.
Current Deployment Status
The project is currently live.
The deployed AWS components include:
- DynamoDB
- Cognito
- Lambda
- API Gateway
- S3
- EventBridge
- SNS
- ECR
A demo shop has also been seeded and the demo login has been verified end to end.
Amplify Hosting currently serves the frontend while the CloudFront setup is pending AWS account verification.
What Is Still Pending?
The project is functional, but several integrations are intentionally transparent about their current state.
Bedrock
The application has the Bedrock integration and IAM wiring, but account-level model access is currently unavailable.
The application remains fully functional without Bedrock.
WhatsApp Reminders
The WhatsApp payment reminder integration is implemented, but the Meta message template is still pending approval.
The application therefore refuses to send the reminder until the template is approved.
Transcribe and Textract
The services are wired through CDK and IAM, with deployment pending for the feature flags.
CloudFront
CloudFront hosting is blocked by AWS account verification, while Amplify Hosting serves the application in the meantime.
Known Gaps
The current implementation also has some known limitations.
The sample-data onboarding toggle currently acknowledges the request but does not actually seed the data.
The system also does not yet support product pack sizes, which can cause incorrect pricing in cases such as selling tea by packet when the product is configured per kilogram.
Amplify was created outside CDK to obtain a deployment URL quickly, meaning
cdk destroy does not currently remove that resource.There are also 11 pre-existing lint warnings, with zero lint errors.
What We Learned
Building Vyapio highlighted an important lesson:
AI should not be responsible for facts that deterministic software can calculate.
A language model can make an explanation more natural.
It should not decide how much money a customer owes.
Similarly, AI can help interpret a request.
It should not silently modify a shop's financial records.
This led to an architecture where:
Deterministic code handles truth.
AI handles interpretation and explanation.
The human handles final approval for consequential actions.
That separation makes the system more trustworthy.
The Bigger Vision
The goal of Vyapio is not simply to digitize a notebook.
It is to create a practical digital assistant for small businesses that operate through relationships, memory, and everyday conversations.
A shopkeeper should be able to ask:
"Who still owes me money?"
"Which items are running low?"
"What did I sell today?"
"Who owes me more than ₹500 and is overdue?"
And the system should be able to turn those questions into useful answers from the shop's own records.
The technology should adapt to the shopkeeper, not the other way around.
Conclusion
Vyapio started with a simple observation:
Small shops have a lot to remember.
Customers, payments, inventory, orders, suppliers, sales, and daily business decisions all compete for the shopkeeper's attention.
Vyapio gives that shop a digital memory.
By combining voice-first interaction, deterministic financial logic, offline support, multilingual interfaces, AI-assisted insights, and AWS services such as DynamoDB, Lambda, Cognito, API Gateway, S3, EventBridge, SNS, ECR, Bedrock, Transcribe, and Textract, Vyapio brings these workflows together into one system.

The most important part of the architecture is not the number of AWS services.
It is the boundary between automation and trust:
AI can help understand. Deterministic code keeps the numbers correct. The shopkeeper remains in control.
That is the idea behind Vyapio:
Less to remember. More room to grow.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article