Built to order

Scrap Pickup Booking Web App with Material Rate Card and Pickup Scheduling

This project builds a web app for booking doorstep scrap pickups: customers browse a per-kg rate card, book a slot with their address, and track the booking from scheduled to paid. Pickup agents get an assigned-job list, enter digital-scale weights per material, and the app computes the payout automatically; an admin manages rates, agents and revenue. It demonstrates multi-role authentication, a slot-booking workflow and a money-safe payout calculation in one build. Suitable for B.E./B.Tech final-year projects in Computer Science, Information Technology and Web Development.

Computer / IT FlaskPostgreSQLPython 3HTML5 · CSS3 · JavaScriptSQLAlchemyFlask-LoginTwilio · MSG91 SMSGunicorn · NginxSoftware
Scrap Pickup Booking Web App with Material Rate Card and Pickup Scheduling — project thumbnail preview
More project photos (2)

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.

SYSTEM FLOW

5 components 5 connections

Live flow
Drag to explore
100%
userCustomer

Checks the rate card and books a pickup with date, time slot and materials.

Follow the working sequence

How it works

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

Related guides

All guides

React vs Django vs Laravel: Picking the Right Stack for Your Final-Year Web Project

React, Django, or Laravel for your final-year web project? First, fix the category error: React is a frontend UI library that needs a backend, while Django and Laravel are full-stack backends. This guide compares the three on learning curve, project fit, hosting cost and job relevance, with a decision table, a code comparison of the same feature three ways, and rules for when a React SPA is overkill — so you commit to a stack with evidence, not hype.

Read guide

Razorpay Payment Integration: UPI and Card Payments for Your Project Website

How do you add UPI and card payments to a project website? With Razorpay, the flow is: your server creates an order (amount in paise, never trusted from the client), the Checkout popup collects the payment, your server verifies the HMAC-SHA256 payment signature, and a webhook confirms capture even if the buyer closes the tab. This guide walks through test mode, order creation, signature verification, webhooks, refunds, and the going-live checklist — with server-side Node.js code throughout.

Read guide

50+ Final Year Project Ideas for Computer Science (CSE) Students

This guide lists 50+ final-year project ideas for CSE students, grouped by domain — web applications, AI/ML, blockchain, cybersecurity, mobile apps, plus mini-project picks for pre-final year. Each idea carries a one-line scope note covering what it does and the key technologies involved. Pick your idea using four filters: your team's existing skills, a realistic 6–8 month timeline, confirmed access to hardware or datasets, and your project guide's expertise. Several ideas link to full buildable project breakdowns so you can see exactly what's involved before you commit.

Read guide
Get a quotation