The problem
Selling household scrap still runs on phone calls and haggling: the kabadiwala quotes whatever rate suits him that day, households have no way to check whether ₹12/kg for newspaper is fair, and nobody keeps a record of what was sold. On the dealer's side, pickups are coordinated over voice calls, so routes are inefficient and disputes over weights are settled by whoever shouts louder. The result is a thin market where households get underpaid and dealers waste trips. This project builds a three-sided web app that brings the whole transaction into the open: a public per-kg rate card with minimum-quantity rules, slot-based pickup booking with address capture, live booking tracking from scheduled to paid, an agent screen where digital-scale weights are entered per material and the payout is computed automatically, and an admin console that manages rates, assigns agents and watches revenue. Because every number in the payout has an audit trail — rate card version, weighed quantities, applied rates — both sides can verify the transaction instead of arguing about it.
Checks the rate card and books a pickup with date, time slot and materials.
Follow the working sequence
How it works
- The customer opens the rate card page, checks today's per-kg rates and minimum quantities, and fills the booking form (name, 10-digit mobile, address, date, time slot, materials with approximate weights); the frontend validates the phone number and required fields before submitting.
- The backend stores the booking as Scheduled with a generated ID (e.g. BK-1045), a creation timestamp and the estimated payout computed from the current rate card.
- The admin console lists the new booking; the admin assigns a pickup agent from the agent roster, which moves the booking to Assigned and (in the deployed build) triggers an SMS to the customer with the agent's name.
- The agent logs in and sees only their assigned pickups for the day with the customer's address, slot and declared materials; at the doorstep they weigh each material on a digital scale.
- The agent enters the actual weights per material; the frontend multiplies each weight by the rate-card rate and shows the computed payout live; on confirmation the backend stores the actual weights, the applied rate version and the final payout, moving the booking to Picked up → Paid.
- The customer can watch the booking's status stepper advance to Paid, and the admin's revenue dashboard reflects the completed payout.
Tech stack:
- Python 3 + Flask (backend REST API)
- PostgreSQL (bookings, users, rate-card versions, payout records)
- SQLAlchemy (ORM + schema migrations)
- HTML5, CSS3, vanilla JavaScript (frontend)
- Flask-Login (role-based sessions)
- Twilio / MSG91 (booking & assignment SMS — optional integration)
- Gunicorn + Nginx (deployment)
| Parameter | Value |
|---|---|
| User roles | 3 (customer, pickup agent, admin) |
| Scrap categories | 12, configurable (design) |
| Booking slots | 3 per day: 9 AM–12 PM, 12 PM–3 PM, 3 PM–6 PM |
| Payout formula | sum of (weighed kg × active rate), rounded to nearest ₹ (implemented) |
| Rate-card versioning | Each booking stores the rate version used at weighing (implemented) |
| Phone validation | 10-digit Indian mobile pattern (implemented) |
| Concurrency | Single-instance design target; ~50 concurrent bookings expected |
| Data retention | Booking and payout history retained indefinitely (configurable) |
Project features
- [Public material rate card] Live per-kg rates for 12 scrap categories (paper, plastic, metals, e-waste, batteries) with minimum-pickup quantities and pickup rules, refreshable daily by the admin.
- [Slot-based pickup booking] Customer enters name, mobile, address, picks a date and a time slot (9–12 / 12–3 / 3–6), and lists materials with approximate weights; the form validates the phone format and required fields.
- [Booking tracking] Every booking moves through Scheduled → Assigned → Picked up → Paid with a visual stepper, so the customer always knows where their pickup stands.
- [Agent weighing screen] The assigned agent sees only their jobs, enters the actual digital-scale weight per material at the doorstep, and the payout is computed instantly from the active rate card.
- [Automatic payout computation] Payout = sum of (weighed kg × rate) per material, rounded to the nearest rupee; the receipt shows the line-item breakdown for the customer's confirmation.
- [Admin rate-card management] Rates are edited from the admin console and apply immediately to the customer card and the payout calculator; completed bookings keep the rate version that applied at weighing.
- [Agent assignment & revenue view] Admin assigns agents to new bookings from a dropdown, sees all bookings with statuses in one table, and tracks KPIs — total bookings, scrap value collected, pending pickups, active agents.
- [Three-role authentication] Separate customer, pickup-agent and admin logins with role-gated screens, so agents cannot edit rates and customers cannot see other bookings.
What is included
- Complete Flask web app source code (customer, agent and admin modules)
- PostgreSQL schema with migration scripts and seed rate-card data
- Role-based authentication (customer / agent / admin)
- Booking flow, weighing screen, payout calculator and admin console
- Deployment notes (Gunicorn + Nginx) with environment configuration
- Project report PDF (background, requirements, design, methodology, testing)
- PPT presentation for final review
- Viva Q&A preparation document (workflows, database design, security basics)
Limitations & prerequisites
- SMS notifications need a third-party SMS gateway account with its own credits; the demo build stubs these with on-screen toasts.
- Pickup is limited to the service localities configured by the admin — the demo ships with 22 Pune localities; real deployment needs per-city configuration.
- Rates are entered manually by the admin; there is no automatic link to metal-exchange price feeds (listed as future scope).
- The payout assumes the agent's digital scale is accurate; the app does not calibrate or verify weighing hardware.
- No payment-gateway integration for payouts in the base build — payouts are recorded as cash/UPI handed at the doorstep (UPI/QR receipt generation is future scope).
- The app is English-only in the base build; a Hindi/Marathi UI is a documented customization.
Frequently Asked Questions
How is the payout calculated?
Each material's weighed weight in kilograms is multiplied by its rate on the active rate card, and the line items are summed and rounded to the nearest rupee. The booking record stores the rate version used at weighing, so the receipt can be audited later even if rates change the next day.
Can the admin change rates without breaking old bookings?
Yes. Rates are versioned: editing the rate card creates a new version that applies to future weighings, while every completed booking keeps a reference to the rate version that was active when the agent weighed the scrap. Old receipts stay verifiable.
Does the project include SMS notifications?
The code paths are implemented (booking confirmation to the customer, assignment alert), but a live SMS gateway account is required to actually send them — that account and its per-message cost are outside the project. The delivered build shows the same messages as on-screen notifications so the flow is fully demonstrable.
Can this be extended to a mobile app?
Yes, and the backend is ready for it: the Flask API is stateless REST with JSON responses, so a Flutter or React Native app can consume the same endpoints as the web frontend without server changes. Mobile UI work is a separate customization.
What does the agent actually see?
Only their own assigned pickups — booking ID, customer name and phone, address, slot, declared materials, the per-material weight entry fields, and the live computed payout. They cannot view other agents' jobs, edit the rate card, or access the revenue dashboard.
Is this project suitable for a final-year project?
Yes — for Computer Science, IT and Web Development programs. It demonstrates multi-role authentication, a transactional booking workflow, rate versioning, audit-friendly payout computation and a genuinely deployable architecture.
Components & software requirements
- Python 3 + Flask (backend REST API)
- PostgreSQL (bookings, users, rate-card versions, payout records)
- SQLAlchemy (ORM + schema migrations)
- HTML5, CSS3, vanilla JavaScript (frontend)
- Flask-Login (role-based sessions)
- Twilio / MSG91 (booking & assignment SMS — optional integration)
- Gunicorn + Nginx (deployment)
Delivery information
Built-to-order project. Delivery timeline is shared after order confirmation based on current queue.
Support terms
Complete documentation, setup guide, and viva preparation included. Support for setup and explanation provided.
Download free synopsis (PDF)
Enter your name and email — the synopsis PDF downloads immediately. We may send occasional project updates; no spam, unsubscribe anytime.