The problem
Every day, dozens of courier parcels land at a residential society's gate, and the security guard becomes their custodian. In most societies this runs on paper: a register entry, a parcel on a shelf, and a hope that the resident hears about it. Parcels get handed to the wrong person, sit unclaimed for days, or vanish entirely — and when a resident asks "where is my parcel?", nobody can answer with certainty. ParcelGate replaces the register with an Android app built for the guard's phone. Logging a parcel takes under 30 seconds: courier, tracking number, recipient flat picked from the resident directory, parcel type. The resident immediately gets an SMS that their parcel has arrived. At collection time, the guard generates a 4-digit OTP sent to the resident's registered mobile number; the handover completes only when the resident reads it back and the guard enters it. Every receipt and handover is written to an automatic guard log with timestamps, searchable by name, flat or tracking number. Parcels unclaimed beyond 48 hours are flagged for a reminder call, so nothing rots on the shelf.
Logs parcels at the gate, generates handover OTPs and verifies them on the in-app keypad.
Follow the working sequence
How it works
- The delivery agent arrives at the gate; the guard opens ParcelGate and taps "New parcel".
- The guard selects the courier, enters the AWB/tracking number, picks the recipient flat from the resident directory and sets the parcel type — the entry saves to the cloud database in under 30 seconds.
- The backend immediately sends an SMS to the resident's registered number: their parcel has arrived at the gate.
- When someone comes to collect, the guard selects the parcel from the "Awaiting handover" list and taps "Generate OTP" — a random 4-digit, single-use OTP valid for 5 minutes is sent to the resident's number.
- The resident reads out the OTP; the guard enters it on the in-app keypad. A match marks the parcel handed over; a mismatch is rejected and the guard asks the resident to read it again.
- The handover is written to the guard log with timestamp, guard ID and OTP-verified status, and the parcel leaves the awaiting list.
- A scheduled check flags parcels unclaimed for 48+ hours; the guard sees the alert on the log screen, makes the reminder call, and that call is logged too.
Tech stack:
- Kotlin, Android SDK (min API 28)
- Android Studio
- Firebase Firestore (cloud database)
- Firebase Authentication (guard login)
- Firebase Cloud Messaging (push notifications)
- SMS gateway API (MSG91 / Twilio) for OTP delivery
- Material Design 3 components
- Git
| Parameter | Value |
|---|---|
| Minimum Android version | API 28 (Android 9.0) |
| OTP length | 4 digits, single-use |
| OTP validity | 5 minutes (configurable) |
| Parcel logging time | Under 30 seconds (design target) |
| OTP delivery time | Approximately 10–60 seconds (gateway and network dependent) |
| Handover verification | Under 10 seconds after OTP entry (design target) |
| Unclaimed escalation | 48 hours (configurable) |
| Data storage | Cloud database; retention per society policy (expected) |
| Connectivity | Internet required for sync and OTP; entries queue offline until reconnect (expected) |
Project features
- [30-second parcel logging] The guard records courier, AWB/tracking number, recipient flat (picked from the resident directory) and parcel type the moment the delivery agent hands it over — no freehand flat numbers, no paper register.
- [OTP-verified handover] Before handing over, the guard generates a 4-digit OTP sent by SMS to the resident's registered number; the resident reads it out, the guard enters it on the in-app keypad, and only a match completes the handover.
- [Automatic guard log] Every receipt and handover is written to a chronological log with timestamp, guard ID, courier, tracking number and OTP-verified status — nothing depends on the guard remembering to write it down.
- [Resident arrival SMS] The moment a parcel is logged, the resident gets an SMS naming the courier and tracking number, so parcels stop piling up unnoticed at the gate.
- [48-hour unclaimed escalation] A scheduled check flags parcels unclaimed beyond 48 hours and prompts the guard to make a reminder call; the escalation itself is recorded in the log.
- [Search and filters] The log is searchable by resident name, flat number or tracking number, with filters for received, handed-over and unclaimed — answering "did my parcel come?" takes seconds.
- [Resident directory] The society admin maintains the flat-to-resident mapping with registered mobile numbers, so OTPs and SMS alerts always reach the right person.
What is included
- Complete Android source code (Kotlin) with all three screens: Home, Handover, Guard Log
- Firebase backend configuration guide (Firestore schema, auth rules, FCM setup)
- SMS gateway integration module with a test-mode switch for demoing without credits
- Resident directory import template (CSV)
- Setup and build instructions (debug build + signed release APK)
- Project report PDF (architecture, data flow, OTP design, testing notes)
- PPT presentation for final review
- Viva Q&A preparation document (Android lifecycle, Firebase, OTP security, runtime permissions)
Limitations & prerequisites
- OTP delivery depends on the SMS gateway and the mobile network — during congestion, delivery can take a few minutes and the guard must wait for the resident to receive it.
- Internet connectivity is required to sync records and send OTPs; without it, new entries queue on the device and sync when the connection returns.
- The app verifies the OTP, not the person's identity — anyone holding the resident's phone can collect the parcel; this is a documented design assumption.
- Resident mobile numbers must be kept current in the directory — a changed number breaks both arrival SMS and OTP delivery until updated.
- The app tracks parcels only from gate receipt onward; it has no visibility into the courier's network before delivery.
- SMS gateway usage is billed per message by the provider (typically a few paise per SMS in India); the society bears that running cost.
Frequently Asked Questions
How does the OTP verification actually work?
When the guard taps "Generate OTP", the backend creates a random 4-digit code valid for 5 minutes and sends it by SMS to the resident's registered mobile number. The resident reads it aloud, the guard enters it on the in-app keypad, and only a match completes the handover. Each OTP is single-use and expires automatically.
What if the resident sends someone else to collect the parcel?
The OTP goes to the resident's registered number, so the collector needs the resident to forward the code — which is exactly the authorization the system wants. The guard log records the handover as OTP-verified regardless of who physically carried the parcel.
Does the guard need internet all the time?
Yes, for the core flow: saving records to the cloud database, sending the arrival SMS, and generating OTPs all need connectivity. If the network drops, entries are queued on the phone and synced when it returns — but OTP handovers must wait for the connection.
Can the society customize the unclaimed-parcel rule?
Yes. The 48-hour escalation threshold is configurable — a society can set 24 hours, 72 hours, or disable the reminder prompt entirely. The resident directory and SMS message templates are managed from the admin side, and custom templates let the society use its own name and gate number in alerts.
Is this project suitable for a final-year project?
Yes — for Computer Engineering, IT, and mobile-application programs. It demonstrates Android app development with Kotlin, cloud backend integration with Firebase, third-party SMS API integration, and a real-world authentication workflow, all wrapped in a real society-gate problem every student instantly understands and can demo live. Suitable for B.E./B.Tech final-year projects in Computer Engineering, IT and Android App Development.
Components & software requirements
- Kotlin, Android SDK (min API 28)
- Android Studio
- Firebase Firestore (cloud database)
- Firebase Authentication (guard login)
- Firebase Cloud Messaging (push notifications)
- SMS gateway API (MSG91 / Twilio) for OTP delivery
- Material Design 3 components
- Git
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.