You are acting as a Senior Product Designer, Principal Frontend Engineer, UI/UX Architect, PWA Specialist and Product Strategist.
Your task is to design and IMPLEMENT a premium, production-quality, fully responsive frontend for a startup product named HAAT.
Do not simply create a landing page or a collection of static dashboard screenshots. Build a complete, interactive, multi-role frontend prototype that can be demonstrated to real Indian kirana shop owners, their employees and customers.
The application must feel like a real commercial product developed by an experienced design and engineering team.
Product Name: HAAT
Tagline: Your Local Market, Digitally Connected.
Product Category: AI-powered Hyperlocal Commerce and Shop Operations Platform.
HAAT helps traditional neighbourhood shops digitise their ordering and preparation workflow.
HAAT is not just an online listing of local shops.
It is a digital operating system for neighbourhood commerce.
Product motto: Less Waiting. Better Shopping. Smarter Shops.
The chosen project name is magic-meta.
In Indian kirana stores, customers generally place orders in three ways:
They physically visit the shop and give a handwritten shopping list (parcha).
They call the shopkeeper and dictate their shopping list.
They send their shopping list through WhatsApp using text, voice notes or photographs.
The shopkeeper or employees then manually read the parcha, collect each product, calculate the price and hand the order to the customer.
Customers frequently have to wait 10–30 minutes, especially during busy hours. Other walk-in customers also experience delays.
HAAT aims to make this process organised and efficient.
HAAT must have four distinct modules:
Super Admin.
Shop Owner.
Shop Staff.
Buyer.
All modules must have a unified visual identity but different interfaces and permissions.
THIS IS THE MOST IMPORTANT MODULE.
The majority of HAAT's product value will be experienced here.
The shop owner will use an Android phone most of the time.
The owner should be able to open the application and understand the current situation immediately.
Our first objective is to help kirana shopkeepers manage physical parchas, WhatsApp orders, employee preparation and customer pickup through one simple mobile-first platform.
Instead:
Use realistic mock data.
Create simulated AI extraction results.
Make frontend interactions functional.
Persist demonstration data using localStorage.
Create service abstractions so backend APIs can be integrated later.
Clearly label simulated integrations where necessary.
Do not pretend simulated actions are live external integrations.
Make HAAT installable as a Progressive Web App.
Implement:
Web app manifest.
App name and short name.
App icons and favicon.
Theme colour.
Standalone display mode.
Service worker.
Offline fallback screen.
Install guidance.
Appropriate mobile viewport settings.
Create a role-based demonstration entry point where users can choose which module to preview.
Suggested routes:
/demo
/admin
/admin/shops
/admin/shop-onboarding
/admin/users
/admin/analytics
/admin/settings
/owner
/owner/orders
/owner/orders/:id
/owner/analytics
/owner/staff
/owner/products
/owner/shop-profile
/owner/settings
/staff
/staff/orders
/staff/scan-parcha
/staff/orders/:id
/staff/my-activity
/buyer
/buyer/discover
/buyer/shop/:id
/buyer/create-order
/buyer/orders
/buyer/orders/:id
/login
Add appropriate protected-route-style demo navigation, while making clear that actual authentication is not implemented.
The Super Admin is the platform-level administrator.
Admin must be able to view and manage the entire HAAT platform.
This module should be desktop-first but responsive.
Display:
Total registered shops.
Active shops.
Suspended shops.
Total orders today.
Total orders this month.
Active shop owners.
Total registered staff.
Platform-level order trends.
Create realistic charts:
Shop registration growth.
Monthly order volume.
Shop category distribution.
Active versus inactive shops.
Top-performing shops.
Add a recent activity feed.
Display a comprehensive shop table containing:
Shop name.
Owner name.
Phone number.
Shop category.
Location.
Registration date.
Staff count.
Order count.
Subscription plan.
Current status.
Features:
Search shops.
Filter by category.
Filter by active/inactive status.
View shop details.
Edit shop profile.
Activate shop.
Suspend shop.
View assigned staff.
View shop activity.
This is especially important.
HAAT's internal onboarding team will initially set up merchants for them.
Create an elegant multi-step shop onboarding wizard.
Steps:
Shop Information.
Owner Information.
Contact Information.
Location and Address.
Business Category.
Operating Hours.
Staff Details.
Account Setup.
Review and Confirm.
Fields should include:
Shop Name
Shop Category
Owner Name
Owner Phone Number
Shop Address
City
Pincode
Opening Time
Closing Time
Number of Staff
Staff Names
Staff Phone Numbers
Add validations.
Show a polished onboarding success screen with the newly created shop profile.
The owner should not have to repeat this setup every time they log in.
Create:
Staff management.
User management.
Subscription overview.
Plan status.
Shop account status.
Platform configuration.
The HAAT team will initially configure the shop profile.
The owner receives access to their shop dashboard.
Provide a simple dashboard entry action:
"Open My Dashboard"
The owner should be able to access the dashboard with minimum friction.
After first login, show a friendly welcome screen:
"Namaste, Sharma Ji!"
"Welcome to your HAAT Shop Dashboard."
Show the shop's name, category and status.
Do not force the owner through a long configuration flow.
This is the first screen.
Design for mobile before desktop.
Display a personalised greeting:
"Namaste, Sharma Ji 👋"
Show current store status:
Open / Closed / Temporarily Paused.
Show four important metrics:
Today's Orders.
Preparing.
Ready for Pickup.
Completed.
Show:
Today's order count.
Today's estimated sales.
Pending orders.
Average preparation time.
Recent orders.
Busy-hour indicator.
Use clear numbers and simple descriptions.
Provide primary quick actions:
View New Orders.
View All Orders.
Manage Staff.
View Analytics.
The most important action should be obvious.
This is a core feature.
Display a unified order inbox containing orders from:
WhatsApp.
Physical Parcha.
Phone Orders.
Each order card should include:
Order ID.
Customer name.
Source type.
Received time.
Requested pickup time.
Number of items.
Quantity summary.
Current status.
Assigned staff member.
Create filters:
All
New
Accepted
Preparing
Ready
Picked Up
Cancelled
Support search by customer and order ID.
When the owner opens an order, display:
Customer Information
Order Number
Order Source
Received Time
Requested Pickup Time
Product List
Quantity
Unit
Item Availability
Staff Assignment
Preparation Status
Final Price
Pickup Code
Provide owner controls:
Accept Order
Reject Order
Assign Staff
Edit Quantity
Mark Item Unavailable
Suggest Substitution
Enter Final Price
Mark Ready for Pickup
Require suitable confirmation for important actions.
Never automatically mark an order ready merely because the AI has extracted the items.
Only allow Ready status after preparation is complete and final pricing is entered.
Mark Picked Up
Require suitable confirmation for important actions.
The owner must be able to understand how their business is performing.
Create an understandable analytics area.
Show:
Today's sales.
Weekly sales.
Monthly sales.
Previous-period comparison.
Sales trend chart.
Total orders.
WhatsApp orders.
Physical parcha orders.
Phone orders.
Completed orders.
Cancelled orders.
Average preparation time.
Show:
Most demanded items.
Most frequently ordered products.
Product quantity sold.
Weekly product demand.
Monthly product demand.
Show:
Total customers.
Repeat customers.
New customers.
Frequently ordering customers.
Use readable charts and concise explanations.
Do not overcrowd the mobile screen with charts.
Use Recharts.
All analytics must be based on consistent mock order data.
Distinguish estimated order revenue from actual collected payments.
The owner should be able to:
Add an employee.
Edit employee information.
Activate or deactivate an employee.
Assign roles.
Assign orders.
View employee activity.
View completed orders per employee.
Roles can include:
Store Manager.
Order Operator.
Picking Staff.
Make permissions clear and easy to understand.
Show:
Shop name.
Shop category.
Shop logo/image.
Owner details.
Address.
Opening hours.
Contact details.
Shop status.
Provide editable profile details.
Create an optional lightweight product management interface.
Show:
Product name.
Brand.
Unit.
Category.
Price.
Availability.
Aliases.
Support adding, editing and searching products.
Display:
"Good morning, Amit!"
Show:
Assigned orders.
New orders.
Orders in preparation.
Orders completed today.
Primary actions:
Scan Parcha.
View Assigned Orders.
Add Manual Order.
This is a critical demonstration feature.
Create a mobile-first scanning interface.
Include:
Camera capture.
Image upload.
Image preview.
Retake photo.
Use sample parcha.
Extracted product list.
Where browser camera permission is available, use the camera through the appropriate browser API. Provide upload as a fallback.
Do not make this interface dependent on actual AI APIs.
Simulate the extraction with realistic sample data and a convincing processing-state animation.
Example extracted result:
Aashirvaad Atta — 5 kg
Tata Salt — 2 packets
Amul Butter — 1 packet
Fortune Oil — 1 litre
Arhar Dal — 2 kg
Each extracted item must be editable.
The staff member must be able to:
Change product name.
Change quantity.
Change unit.
Remove incorrect items.
Add missing items.
Confirm the list.
After confirmation, create a new order in the shared order queue.
Clearly label AI extraction as a demonstration simulation.
When staff opens an assigned order, display:
Order Number
Customer Name
Pickup Time
Product List
Quantity
Item Checkboxes
Availability Status
Special Instructions
Each item should have a clear checkbox.
As employees collect products, they can mark the items complete.
Show a visible preparation progress indicator.
When all items are collected, allow staff to submit the order as ready for owner confirmation or final pricing, depending on permissions.
Provide a very simple form for orders received through phone calls.
Fields:
Customer Name
Phone Number
Product Name
Quantity
Unit
Customer Instructions
Add multiple line items.
Save the order to the same order queue.
Show:
Orders handled today.
Orders completed.
Current assigned workload.
Recent activities.
However, create a lightweight mobile-first buyer experience so that we can demonstrate the complete future customer journey.
This should behave like a simple local-shopping PWA or public web storefront.
Create a visually appealing discovery screen.
Display:
Search bar.
Shop categories.
Nearby shops (mock location data).
Featured shops.
Shop opening status.
Store information.
Available pickup options.
Initial demo categories:
Kirana
Dairy
Bakery
Fruits & Vegetables
General Store
Use realistic Indian shop names and product examples.
Show:
Shop name.
Shop banner.
Contact details.
Address.
Opening hours.
Categories.
Popular products.
Shop pickup details.
Create a simple order-building experience.
Customers can:
Search products.
Add products.
Change quantities.
View order summary.
Add a special instruction.
Select a preferred pickup time.
Submit a simulated order request.
Display a confirmation screen with an order number.
For the frontend demonstration, simulate the order creation locally.
Add an explanation that WhatsApp messaging will be integrated in a future phase.
Show:
Order Received
Confirmed
Preparing
Ready for Pickup
Picked Up
Create a clear tracking timeline.
Display:
Shop name.
Order ID.
Items.
Final amount.
Pickup code.
Pickup information.
Add a reorder interaction.
Implement:
Role-based demo entry.
Navigation between all modules.
Search and filters.
Interactive order cards.
Order detail pages.
Order status changes.
Order acceptance and rejection.
Staff assignments.
Product checklists.
Manual order creation.
Parcha image upload and preview.
Simulated AI extraction.
Item editing and deletion.
Final-price form.
Ready-for-pickup action.
Pickup completion.
Analytics date filters.
Shop onboarding wizard.
Staff creation.
Shop profile editing.
Buyer order creation.
Buyer order tracking.
When an owner marks an order ready, the buyer's simulated order tracking screen should update.
Role switching.
Demo data reset.
Include a demo reset control.
When staff completes an item, the order progress shown to the owner should update.
All modules should operate on shared demonstration data.
Use a central mock data service or context/store rather than keeping unrelated copies of order information in each screen.
Persist relevant changes using localStorage.
The same order must show the same price, items and status across all modules.
Create a premium public landing/demo entry page.
Hero headline:
"Your Shop. Smarter. Faster. Online."
Supporting copy:
"Manage every parcha, prepare orders faster and serve customers without unnecessary waiting."
Primary CTA:
"Explore HAAT"
Secondary CTA:
"See How It Works"
Include:
Problem explanation.
How HAAT works.
Owner dashboard preview.
Staff parcha scanning preview.
Order preparation workflow.
Buyer experience preview.
Benefits for local shopkeepers.
Four module explanations.
A demo role selector should allow the presenter to instantly open:
Admin Demo
Shop Owner Demo
Staff Demo
Buyer Demo
This is extremely important because I will demonstrate the prototype directly to local shopkeepers.
Provide convenient demo-account access rather than making a presenter fill a long registration form.
Thoughtful empty states.
Proper loading states.
Helpful success and error messages.
All important buttons must perform a meaningful frontend action.
A shop owner should be able to:
Open their dashboard.
See how many new orders arrived.
Open a customer order.
View all requested products and quantities.
Assign an employee.
Enter a final amount.
Mark an order ready.
View daily and monthly analytics.
A staff member should be able to:
Open the staff dashboard.
Scan or upload a physical parcha.
Review extracted products.
Correct the list.
Create the order.
Open assigned orders.
Complete product checklist items.
Update preparation progress.
A buyer should be able to:
Find a sample shop.
Open the storefront.
Create an order.
View its tracking status.
An admin should be able to:
View registered shops.
Onboard a new merchant.
Edit shop information.
Manage shop status.
View platform analytics.
STEP 3:
Implement the shared routing, layouts and role-based demo entry.
STEP 4:
Implement the Shop Owner module first because it is our most important module.
STEP 5:
Implement the Staff module, including the parcha scanner and picking checklist.
STEP 6:
Implement the Admin module and shop onboarding wizard.
STEP 7:
Implement the Buyer storefront and order tracking experience.
STEP 9:
Implement responsive PWA functionality.
STEP 11:
Test navigation, form validation, shared data changes and all main user workflows.
If some advanced functionality cannot be implemented without a backend, create an honest and polished frontend simulation.
Desktop-ready admin and owner dashboards.
Four fully navigable modules.
Shared interactive demo data.
Functional order management prototype.
Staff parcha scanner demonstration.
Analytics dashboards.
Merchant onboarding wizard.
Buyer storefront and tracking.
App icons and PWA manifest.
README with setup instructions.
Demo credentials or one-click demo access.
Known frontend-only limitations.
Build and validation results.
The final application should run locally using the documented development command.
The prototype must be impressive enough to demonstrate to real kirana shop owners and buyers.
Example shop:
Sharma Kirana & General Store
Owner: Rajesh Sharma
Staff:
Amit Kumar — Store Manager
Rahul Verma — Picking Staff
Suresh — Order Operator
Create several realistic demo customers:
Rahul
Priya
Amit
Neha
Ramesh
Actors: Customer, shop owner, shop staff.
Trigger: The customer needs groceries and sends a shopping list by WhatsApp (text, voice note or photograph), by phone, or in person as a handwritten parcha.
Branches and recovery: Rejected orders leave the queue as Cancelled. Unavailable items are resolved through quantity edits or substitutions before pricing. Important status changes (Ready, Picked Up) require confirmation. Orders can be searched by customer or order ID and filtered by All, New, Accepted, Preparing, Ready, Picked Up, Cancelled. Statuses follow the defined set: NEW, NEEDS_CLARIFICATION, AWAITING_ACCEPTANCE, ACCEPTED, PREPARING, AWAITING_CUSTOMER_APPROVAL, READY_FOR_PICKUP, PICKED_UP, CANCELLED, REJECTED.
Result: The customer collects a prepared, priced order without the 10–30 minute in-store wait; the order closes as Completed.
Actors: Shop staff, shop owner (downstream).
Trigger: A parcha arrives at the shop and must enter the digital queue.
Result: A new order is created in the shared order queue, where it follows journey 1 from acceptance onward.
Actors: Shop staff, shop owner (downstream).
Trigger: A customer places an order by phone call.
Result: The order is saved to the same shared order queue and follows journey 1 from acceptance onward.
Actors: Shop staff.
Trigger: Staff want to see their current work.
Result: Staff know what remains to be prepared and pick up assigned orders directly.
Actors: HAAT internal onboarding team (Super Admin), shop owner (recipient).
Trigger: A new kirana shop joins the platform.
Result: The shop and its owner account exist once; the owner does not repeat this setup at each login.
Actors: Shop owner.
Trigger: The owner receives access after HAAT configures the shop profile.
Result: The owner reaches the home dashboard with minimum friction; no long configuration flow is forced. The home screen shows store status (Open / Closed / Temporarily Paused), the four metrics (Today's Orders, Preparing, Ready for Pickup, Completed), today's order count, estimated sales, pending orders, average preparation time, recent orders, busy-hour indicator and most demanded products, with quick actions to View New Orders, View All Orders, Manage Staff and View Analytics.
Actors: Shop owner, staff member.
Trigger: The owner needs to add or adjust shop employees.
Result: Staff are available for order assignment in journey 1 and their activity is traceable.
Actors: Shop owner.
Trigger: The owner wants to understand how the business is performing.
Result: The owner has an understandable view of sales, order mix and demand to guide stocking and staffing.
Actors: Shop owner.
Trigger: Product details or shop details change.
Result: The catalogue and profile stay accurate for order preparation and customer discovery.
Actors: Super Admin.
Trigger: Routine platform administration.
Result: Shops remain correctly provisioned and their subscription and account status reflect current standing.
Actors: Buyer, shop owner/staff (fulfilment).
Trigger: The buyer wants to order from a nearby shop through the lightweight mobile-first storefront.
Result: The order proceeds through the shop's queue as in journey 1.
Actors: Buyer, shop owner (status changes).
Trigger: The buyer wants to know the state of a placed order.
Result: The buyer knows when and how to collect the order and can repeat a past order.
Actors: Presenter (demonstrating to shopkeepers), demo roles.
Trigger: The presenter wants to show the prototype without registration.
Result: Each module is reachable in one step for live demonstration; navigation between all modules and shared demo data keep changes visible across roles.
Customer sends a shopping list → Order enters the shop's digital queue → Staff prepares the products → Shopkeeper confirms the final price → Customer receives a ready notification → Customer visits and collects the order.
[Design proposal; unspecified choices are defaults.]
HAAT reads as a carefully designed Indian retail technology startup: trustworthy, friendly, efficient, modern, approachable, professional and local-market inspired. The muse is Aaron Draplin — bold, honest shop craft. Thick-line badges, workwear colours and plain talk suit kirana shopkeepers, their staff and local buyers who need a 30-second read on a phone. Usability is never sacrificed for decoration.
Colour tokens (light mode, authoritative):
| Role | Token |
|---|---|
| Background | #F7F6F0 warm ivory |
| Surface | #FFFFFF |
| Primary text | #202C26 |
| Secondary text | #78827C |
| Primary (actions, status) | #176B4A forest green |
| Dark green | #124B37 |
| Accent (single hot accent) | #D98660 terracotta |
| Badge fill | #D9EE9B soft lime |
| Border | #E7E9E3 |
| Success | #28845A |
| Warning | #D99734 |
| Error | #C94E4E |
Backgrounds stay predominantly light; green communicates important actions and statuses; cards are not all filled with colour. Soft lime fills small badges only.
Typography: Manrope for headings at 700–800 weight with tight tracking on large numbers; DM Sans for interface text. Modular 1.25 scale: 44/34/26/20/16/14. Hero headline clamp(38px, 7vw, 84px). All-caps DM Sans labels at 11px with 0.12em tracking. Large but restrained page headings, readable labels, strong numerical hierarchy, comfortable line height, no body copy below 14px.
Shape and spacing: hard 8px and 12px radii on panels, 2px ink borders, chunky badge stamps and ruled dividers — no soft blobs. Consistent spacing, radius, typography and shadow tokens; subtle shadows only.
Imagery: thick-line SVG icons of baskets, sacks and weighing scales; halftone photographs of Indian shop shelves used once per section, never randomly and never generic stock illustration.
Responsive: mobile-first for the owner dashboard — bottom navigation for Owner and Staff, minimum 44px touch targets, full-width order cards, no horizontal scrolling, no tiny data tables, cards instead of compressed tables, safe-area respect, mobile-friendly sheets and dialogs, sticky primary actions where helpful. Desktop at 1024/1280/1440px uses sidebar navigation, top toolbar, multi-column dashboards, real data tables and spacious analytics. The two are thoughtfully adapted, not scaled copies.
Avoid: purple/blue gradients on white, glassmorphism, soft blobs, emoji as navigation icons, grids of identical hover-lift cards, tiny text, decorative art covering a button or label, generic AI dashboard aesthetics, excessive gradients, overuse of rounded cards, giant headings in operational screens.
Readable text and controls stay whole at 375px, 768px and 1280px; imagery and decoration may bleed, rotate or overlap freely.
Trustworthy.
Friendly.
Efficient.
Modern.
Approachable.
Professional.
Local-market inspired.
Use a coherent design system.
Suggested palette:
Primary Forest Green: #176B4A
Dark Green: #124B37
Warm Ivory: #F7F6F0
Pure White: #FFFFFF
Soft Lime: #D9EE9B
Terracotta Accent: #D98660
Primary Text: #202C26
Secondary Text: #78827C
Border: #E7E9E3
Success: #28845A
Warning: #D99734
Error: #C94E4E
Keep backgrounds predominantly light.
Use green to communicate important actions and statuses.
Do not fill every card with coloured backgrounds.
Use Manrope for headings and DM Sans for interface text.
Make the hierarchy clear:
Large but restrained page headings.
Readable labels.
Strong numerical hierarchy.
Comfortable line height.
No unnecessarily tiny text.
Avoid:
Generic AI dashboard aesthetics.
Excessive gradients.
Purple and blue gradient everywhere.
Excessive glassmorphism.
Overuse of rounded cards.
Unnecessary giant headings in operational screens.
Decorative elements that obstruct task completion.
Generic stock illustrations.
Emoji used as the main navigation icon.
Use meaningful product photography selectively, not randomly.
Build consistent spacing, border radius, typography and shadow tokens.
Design a professional sidebar with:
Overview
All Shops
Onboard Shop
Users & Staff
Analytics
Subscriptions
Activity Logs
Settings
Admin dashboard should look like a serious SaaS control centre.
The UI should look premium and memorable without feeling artificial.
The result should look like a professionally funded Indian technology startup product.
Use:
Carefully designed spacing.
Consistent visual hierarchy.
Strong responsive layouts.
Subtle shadows.
Excellent typography.
Meaningful illustrations.
High-quality product visuals.
Beautiful charts.
STEP 2:
Create a coherent design system and HAAT brand identity.
[Design proposal; unspecified choices are defaults.]
HAAT wordmark and icon. An original HAAT wordmark in Manrope 800, paired with a simple custom SVG icon combining an abstract market/store or shopping-basket motif. No existing startup logos are copied.
Poster-like layout. Blocks on a 12-column grid. A forest-green headline block spans the viewport edge to edge on the landing page. A terracotta circular badge with the HAAT basket icon is stamped at a slight angle on each section opener. A thick ruled divider with an all-caps label separates every dashboard section.
Order cards. 2px ink border with a left status stripe that changes colour by order state — the recurring operational object across Owner, Staff and Buyer surfaces.
Parcha scan panel. A moving ink-line sweep with a stamped 'Extracted' mark on completion; extraction is simulated with realistic sample data and a convincing processing state, never dependent on live AI APIs.
Public entry hero. A full-bleed warm-ivory poster: a giant forest-green headline block fills the left two thirds with "Your Shop. Smarter. Faster. Online."; a terracotta badge stamp with the basket icon sits at the top right; the subline "Manage every parcha, prepare orders faster and serve customers without unnecessary waiting." sits under the headline; the primary CTA "Explore HAAT" is a solid green bar pinned beneath it, with secondary "See How It Works". The page continues into problem explanation, how HAAT works, owner dashboard preview, staff parcha scanning preview, order preparation workflow, buyer experience preview, benefits for local shopkeepers and the four module explanations.
Admin control centre. A professional sidebar — Overview, All Shops, Onboard Shop, Users & Staff, Analytics, Subscriptions, Activity Logs, Settings — reading as a serious SaaS control centre, with realistic charts for shop registration growth, monthly order volume, category distribution, active versus inactive shops and top-performing shops. The multi-step merchant onboarding wizard ends on a polished success screen showing the newly created shop profile.
Owner welcome. After first login, a friendly screen: "Namaste, Sharma Ji!" / "Welcome to your HAAT Shop Dashboard." with shop name, category and status — no forced long configuration flow. The home dashboard leads with the personalised greeting, store status (Open / Closed / Temporarily Paused) and four metrics: Today's Orders, Preparing, Ready for Pickup, Completed, with the most important action obvious.
Buyer discovery. Search bar, categories (Kirana, Dairy, Bakery, Fruits & Vegetables, General Store), nearby shops on mock location data, featured shops, opening status, store information and pickup options, using realistic Indian shop names and products.
Quality bar. Thoughtful empty states, proper loading states, helpful success and error messages, beautiful Recharts analytics on consistent mock order data that distinguish estimated order revenue from actual collected payments, and a demo reset control. Every important button performs a meaningful frontend action; no dead buttons, non-functional navigation, fake API-success messages or meaningless random charts.
Create a distinctive, premium identity for HAAT.
The product should feel like a carefully designed Indian retail technology startup.
Create an original HAAT wordmark.
Develop a simple custom SVG icon combining an abstract market/store or shopping-basket motif.
Do not copy existing startup logos.
[Design proposal; unspecified choices are defaults.]
Interaction Model: Animated Motion Tempo: restrained Hero Dimensionality: flat
Landing Hero Motion Brief. Focal subject: the forest-green headline block and the terracotta basket badge stamp. Input → transformation → outcome: the visitor lands on the warm-ivory poster; the badge stamps in at a slight angle and the green CTA bar snaps into place; the visitor reads the promise and presses "Explore HAAT". Motion vocabulary: snap-in entrances and stamp effects at 160ms, no continuous loops. Composed first frame: headline block left two thirds, badge top right, subline and green CTA bar beneath — fully legible before any motion runs. Reduced-motion state: the same composition rendered static, with no stamp or snap animation.
Framer Motion, meaningful only: smooth page transitions, order card entrance animations, animated status badges, subtle modal transitions, picking checklist progress animation, analytics chart reveal, sidebar transitions, interactive success confirmation, subtle button press feedback and the parcha scanning animation.
3D, selective and CSS-first: a distinctive HAAT brand introduction, a subtle perspective effect on the hero section, a floating order-card visual, depth effects on product visuals and a subtle tilt interaction on selected desktop cards. Use CSS 3D transforms where possible, prioritise performance on low-end Android phones, and never add a heavy Three.js scene to every dashboard screen. Avoid continuous animations that distract shopkeepers from their tasks.
Reduced motion: all motion stops under prefers-reduced-motion, leaving a usable static arrangement.
Use Framer Motion for meaningful interactions.
Examples:
Smooth page transitions.
Order card entrance animations.
Animated status badges.
Subtle modal transitions.
Picking checklist progress animation.
Analytics chart reveal.
Sidebar transitions.
Interactive success confirmation.
Subtle button press feedback.
Parcha scanning animation.
Use 3D effects selectively.
Possible applications:
A distinctive HAAT brand introduction.
Subtle perspective effect on the hero section.
A floating order-card visual.
Depth effects on product visuals.
A subtle tilt interaction on selected desktop cards.
Use CSS 3D transforms where possible.
Prioritise performance on low-end Android phones.
Respect prefers-reduced-motion.
STEP 10:
Add animations, polish, transitions and realistic empty/loading/error states.
The users are traditional Indian shopkeepers and employees, not technology experts.
The UI must be simple enough that a shopkeeper can understand the dashboard within 30–60 seconds.
Never sacrifice usability for decorative design.
This is one of the highest-priority requirements.
Most of our target kirana shop owners use Android smartphones. Many will not have a laptop or desktop computer.
Therefore, mobile UX has priority.
Primary target viewport: 360px–430px width.
Support:
360px Android devices.
390px devices.
412px devices.
Tablet layouts.
Desktop screens.
On mobile:
Bottom navigation for Owner and Staff.
Large, easy-to-tap buttons.
Minimum 44px touch targets.
Readable text without zooming.
Sticky primary actions where helpful.
Full-width order cards.
No horizontal scrolling.
No tiny data tables.
Use cards instead of compressed desktop tables.
Respect device safe areas.
Support 1024px, 1280px and 1440px screens.
On desktop:
Sidebar navigation.
Top toolbar.
Multi-column dashboard layouts.
Proper data tables.
Spacious analytics.
Efficient order management.
The mobile and desktop interfaces must be thoughtfully adapted, not simply scaled versions of each other.
The staff module should be even simpler than the owner dashboard.
Staff members are generally busy collecting products and serving customers.
They must be able to operate the interface with one hand wherever possible.
The buyer module must remain simple and must not distract from the main owner/staff experience.
The prototype must have functional interactions.
This is not negotiable.
Do not add a heavy Three.js scene to every dashboard screen.
Avoid continuous animations that distract shopkeepers from their tasks.
Test the most important workflows at 360px, 390px and 412px viewport widths.
No horizontal overflow, clipped buttons or unreadable text.
STEP 12:
Run the production build and fix all TypeScript errors, compilation errors and broken interactions.
Build HAAT with the quality of a serious startup product, not a hackathon-style temporary dashboard.
The frontend must be architected so that real FastAPI, Supabase and WhatsApp integrations can be introduced without rewriting the entire application.
Inspect the existing repository before starting.
If the repository already has a working stack, preserve it unless there is a strong technical reason to change it.
If it is an empty repository, use:
React + TypeScript
Vite
React Router
Tailwind CSS
Framer Motion
Recharts
Lucide React
React Hook Form + Zod
vite-plugin-pwa
LocalStorage for demo persistence
Keep the application modular and maintainable.
Use TypeScript interfaces for all major data structures.
Avoid putting the entire application in App.tsx.
Suggested architecture:
src/
app/
App.tsx
router.tsx
providers/
components/
common/
navigation/
dashboard/
charts/
orders/
forms/
feedback/
modules/
admin/
pages/
components/
modules/
owner/
pages/
components/
staff/
pages/
components/
buyer/
layouts/
hooks/
services/
mock/
api/
data/
types/
utils/
styles/
assets/
You may improve this structure where appropriate.
STEP 8:
Connect all modules to a shared mock data layer.
HAAT is pickup-first.
We are NOT building a delivery-first business.
IMPORTANT: This development phase is FRONTEND ONLY.
Build the complete frontend prototype with realistic mock data and functional interactions.
Do not implement:
Actual WhatsApp Cloud API integration.
Real AI model/API integration.
Real database/backend.
Real payment gateway.
Real OTP authentication.
Actual production subscriptions.
Do not claim that real-time notifications or offline order synchronisation are available unless actually implemented.
Use mock data.
Do not make a large catalogue mandatory to use HAAT.
Do not create a separate phone-order management system.
Avoid exposing owner-only financial analytics.
A separate native buyer application is NOT required in V1.
Do not request actual device location in the demonstration.
Add an explanation that WhatsApp messaging will be integrated in a future phase.
Seed the application with realistic Indian kirana shop data.
Use currency: INR (₹).
Use quantities and units relevant to Indian grocery stores:
kg, g, litre, ml, packet, piece, dozen, box.
Products:
Aashirvaad Atta.
Rice.
Sugar.
Tata Salt.
Amul Butter.
Milk.
Eggs.
Fortune Oil.
Arhar Dal.
Moong Dal.
Maggi.
Tea.
Biscuits.
Create enough data to populate analytics meaningfully.
Use realistic historical dates and a consistent sample dataset.
Avoid presenting unsupported sales improvements or making false productivity promises.
Do not:
Use Lorem Ipsum.
Use generic placeholder screens.
Add dead buttons.
Create non-functional navigation.
Use fake API-success messages.
Generate meaningless random charts.
Force the buyer module into the owner dashboard.
Display every feature on the mobile home screen.
Overcomplicate operational workflows.
Follow this exact process:
STEP 1:
Inspect the repository, existing dependencies and project structure.
Do not stop after writing a plan or creating a landing page.
Actually implement the full working frontend.
Do not ask me to approve every screen or minor design decision. Make sensible professional decisions and proceed.
At completion, provide:
Complete working HAAT frontend.
Responsive mobile PWA.
Order source types:
PHYSICAL_PARCHA
PHONE
Order statuses:
NEW
NEEDS_CLARIFICATION
AWAITING_ACCEPTANCE
ACCEPTED
PREPARING
AWAITING_CUSTOMER_APPROVAL
READY_FOR_PICKUP
PICKED_UP
CANCELLED
REJECTED

Manage every parcha, prepare orders faster and serve customers without unnecessary waiting.
In Indian kirana stores, customers place orders in three ways: they walk in with a handwritten list, they call the shopkeeper, or they send a list through WhatsApp.
The shopkeeper or an employee then reads the list by hand, collects each product, calculates the price and hands the order over. HAAT aims to make this process organised and efficient.
Shop shelves, read by hand one parcha at a time.
The customer walks in and hands over a handwritten shopping list. Every line is read by hand.
The customer calls the shopkeeper and dictates the list out loud, item by item.
The customer sends the list as text, a voice note or a photograph of the parcha.
One shared queue connects the customer, the staff at the counter and the shopkeeper — from the moment a list arrives to the moment it is collected.
A handwritten parcha or a WhatsApp list arrives at the shop as it always has.
The list becomes a numbered order in one shared queue that every staff member can see.
Employees pick each item against a clear checklist and tick it off as they go.
The owner reviews the basket and sets the final amount before the customer pays.
Once the parcel is ready, the customer is informed that it can be collected.
The customer picks up a prepared parcel at the counter instead of waiting in line.
Sharma Kirana & General Store
Rahul
No long setup, no hunting through menus. The dashboard lands on a personal greeting, the shop’s live status and the four numbers the owner acts on first.
Staff photograph the customer's list. HAAT lays the items into an editable order so the counter can start collecting without re-reading the paper.
Staff can edit quantities or remove an item before the order is confirmed.
Buyers search nearby shops, pick a category and send their list ahead. The shop prepares it, and the buyer collects at pickup — no standing at the counter.
Demonstration preview
What a kirana shop gets back when the parcha is digitised.
List handed in at the counter or sent by phone: the items are laid out on screen for staff instead of being read again from the parcha.
Parcha, phone call and WhatsApp lists land in a single order inbox, so nothing sits unnoticed in three different places.
Each order shows who is picking it, so the store manager knows the work is covered without asking around.
The final price is entered and saved on the order before the customer is told it is ready for pickup.
Less Waiting. Better Shopping. Smarter Shops.
Four Modules
HAAT keeps a unified visual identity across the platform, but each module shows only what that person needs to get the job done.
HAAT internal team
Oversee every shop on the platform — onboarding, shops, users and staff, analytics, subscriptions and activity logs.
Shop ownerMain module
See today’s orders at a glance, work the live order inbox, manage staff and read business analytics.
Shop staff
Scan a handwritten parcha, confirm the item list and pick each product against a simple checklist.
Local customer
Discover nearby shops, send an order for pickup and follow it from request to ready.
Demo access requires sign-in

Manage every parcha, prepare orders faster and serve customers without unnecessary waiting.
In Indian kirana stores, customers place orders in three ways: they walk in with a handwritten list, they call the shopkeeper, or they send a list through WhatsApp.
The shopkeeper or an employee then reads the list by hand, collects each product, calculates the price and hands the order over. HAAT aims to make this process organised and efficient.
Shop shelves, read by hand one parcha at a time.
The customer walks in and hands over a handwritten shopping list. Every line is read by hand.
The customer calls the shopkeeper and dictates the list out loud, item by item.
The customer sends the list as text, a voice note or a photograph of the parcha.
One shared queue connects the customer, the staff at the counter and the shopkeeper — from the moment a list arrives to the moment it is collected.
A handwritten parcha or a WhatsApp list arrives at the shop as it always has.
The list becomes a numbered order in one shared queue that every staff member can see.
Employees pick each item against a clear checklist and tick it off as they go.
The owner reviews the basket and sets the final amount before the customer pays.
Once the parcel is ready, the customer is informed that it can be collected.
The customer picks up a prepared parcel at the counter instead of waiting in line.
Sharma Kirana & General Store
Rahul
No long setup, no hunting through menus. The dashboard lands on a personal greeting, the shop’s live status and the four numbers the owner acts on first.
Staff photograph the customer's list. HAAT lays the items into an editable order so the counter can start collecting without re-reading the paper.
Staff can edit quantities or remove an item before the order is confirmed.
Buyers search nearby shops, pick a category and send their list ahead. The shop prepares it, and the buyer collects at pickup — no standing at the counter.
Demonstration preview
What a kirana shop gets back when the parcha is digitised.
List handed in at the counter or sent by phone: the items are laid out on screen for staff instead of being read again from the parcha.
Parcha, phone call and WhatsApp lists land in a single order inbox, so nothing sits unnoticed in three different places.
Each order shows who is picking it, so the store manager knows the work is covered without asking around.
The final price is entered and saved on the order before the customer is told it is ready for pickup.
Less Waiting. Better Shopping. Smarter Shops.
Four Modules
HAAT keeps a unified visual identity across the platform, but each module shows only what that person needs to get the job done.
HAAT internal team
Oversee every shop on the platform — onboarding, shops, users and staff, analytics, subscriptions and activity logs.
Shop ownerMain module
See today’s orders at a glance, work the live order inbox, manage staff and read business analytics.
Shop staff
Scan a handwritten parcha, confirm the item list and pick each product against a simple checklist.
Local customer
Discover nearby shops, send an order for pickup and follow it from request to ready.
Demo access requires sign-in
No comments yet. Be the first!