Built to order

Housing Society Visitor Management Android App

This project builds a native Android app that replaces the paper visitor register at housing-society gates. Guards log visitors in seconds with purpose, flat and photo capture; the flat owner gets an instant approval request and can approve or deny from the phone; residents generate QR gate passes for expected guests that the guard scans at entry. Every entry and exit is timestamped into a searchable log with daily reports, and an offline queue keeps the gate working when connectivity drops. Built in Kotlin with Jetpack components and Firebase. Suitable for B.E./B.Tech final-year projects in

Android KotlinRoom databaseCameraXAndroid SDK · JetpackMaterial 3Firebase AuthZXing QRCloud Firestore · FCMSoftware
Housing Society Visitor Management Android App — project thumbnail preview
More project photos (3)

The problem

The paper visitor register at a society gate is slow, illegible and useless in an emergency — nobody can answer "who is inside right now?" from a smudged notebook. Guards juggle phone calls to flat owners for every guest, delivery riders wait at the gate, and managing committees have no data on footfall or repeat offenders. This project builds GatePass, an Android app with two faces: a guard app for fast check-ins and a resident app for approvals and passes. A visitor is logged with name, phone, purpose and flat; the owner gets a push request and approves or denies in one tap. Residents pre-generate QR gate passes for expected guests, domestic help and cabs — the guard scans instead of calling. Every event is timestamped into a queryable entry-exit log with filters by date, flat, purpose and status, and the committee dashboard shows live occupancy and daily summaries. An offline write queue keeps the gate operational through network drops, syncing when connectivity returns.

SYSTEM FLOW

5 components 5 connections

Live flow
Drag to explore
100%
userSecurity guard

Logs visitors at the gate with the Android app.

Follow the working sequence

How it works

  1. The guard opens the app, selects the visit purpose and flat, and enters the visitor's name and phone — or scans the visitor's QR pass to pre-fill everything.
  2. If the flat has approval enabled, an FCM push request goes to the resident with the visitor's details; approve/deny writes back to the entry record.
  3. On approval (or for pass-holders), the guard confirms entry; the event is timestamped into the log with the guard's ID.
  4. At exit, the guard taps the active entry to stamp the exit time; the resident can also be notified.
  5. Residents generate QR passes from the resident app: guest name, vehicle number, validity window — encoded as a signed token the guard app verifies offline.
  6. All events sync to Firestore; the committee dashboard aggregates live occupancy and exports daily CSV reports.
  7. Without connectivity, entries queue in Room with device timestamps and sync later, flagged as backfilled.

Tech stack:

  • Kotlin, Android SDK with Jetpack (CameraX, Room, Navigation)
  • Material 3 design components
  • ZXing (QR generation and scanning)
  • Firebase Authentication (guard/resident roles)
  • Cloud Firestore (visitors, passes, approvals)
  • Firebase Cloud Messaging (approval requests)
  • Room (offline entry queue)
Parameter Value
Platform Android 8.0 (API 26) and above (expected)
QR scan time Under ~1 second on mid-range devices (expected)
Check-in time Under ~15 seconds per visitor (design target)
Offline support Full entry capture offline; sync on reconnect (expected)
Pass validity Configurable windows, default same-day expiry
Data retention Configurable; 90 days default in demo (expected)
Build output Debug APK + signed release APK (built-to-order)
Demo dataset 8 visitors, 4 flats, sample passes (included)

Project features

  • [Guard check-in flow] Log a visitor in under 15 seconds: name, phone, purpose, flat, photo capture — with recent-visitor autocomplete for repeat entries.
  • [QR gate passes] Residents generate time-bound QR passes for guests, cabs and deliveries; the guard scans to auto-fill the entry.
  • [Instant resident approvals] The flat owner receives a push approval request with visitor details and approves or denies in one tap.
  • [Entry-exit log] Every gate event timestamped and searchable by date, flat, purpose, visitor name and status — the paper register, queryable.
  • [Pre-approved regulars] Domestic help, drivers and staff get recurring passes so daily entries don't need fresh approvals.
  • [Committee dashboard] Live "who is inside" count, daily footfall summaries and per-flat visitor history for the managing committee.
  • [Offline queue] Entries captured without connectivity are queued in Room and synced to Firestore on reconnect, marked with capture time.

What is included

  • Complete Kotlin Android source code (guard + resident apps, single project)
  • Firestore data model, role-based security rules and indexes
  • Debug APK for testing on a real device
  • Seed dataset: flats, residents, visitors, sample passes
  • Project report PDF (problem analysis, workflow design, schema, screens, testing)
  • PPT presentation for final review
  • Viva Q&A preparation document (QR tokens, offline sync, FCM, Firestore rules)
  • Build and Firebase setup guide

Limitations & prerequisites

  • Visitor identity is self-declared plus photo; the app is a register, not a government ID verification system.
  • QR passes are verified against the local token signature; full server re-validation needs connectivity.
  • One society per deployment in this build; multi-society tenancy is listed as future scope.
  • Push approvals need the resident's phone online; the guard flow falls back to a call button after a timeout.
  • No biometric or ANPR hardware integration in this build.

Frequently Asked Questions

How is this better than a paper register?

Every entry is timestamped, searchable and aggregated — the committee can see live occupancy and daily footfall, and entries can't be torn out or rendered illegible.

What happens when the internet goes down at the gate?

Entries are captured into a Room queue with device timestamps and sync to Firestore on reconnect, flagged as backfilled. QR pass verification uses signed tokens, so it works offline too.

How do QR gate passes prevent misuse?

Each pass is a signed token binding guest name, flat, vehicle and a validity window. The guard app verifies the signature and expiry locally before accepting it.

Can residents approve visitors remotely?

Yes — the approval push goes to the resident's phone anywhere; the guard sees the decision in real time. A timeout falls back to a call-the-flat button.

Who can see the visitor log?

Firestore rules scope it: guards see today's log, residents see their own flat's history, committee admins see everything. The report documents the rule set.

Is this project suitable for a final-year project?

Yes — for Computer Science, IT and related programs. It combines mobile UX for two distinct users, QR cryptography basics, offline-first sync and role-based cloud security around a universally understood problem. Suitable for B.E./B.Tech final-year projects in Computer Science, IT and related programs.

Components & software requirements
  • Kotlin, Android SDK with Jetpack (CameraX, Room, Navigation)
  • Material 3 design components
  • ZXing (QR generation and scanning)
  • Firebase Authentication (guard/resident roles)
  • Cloud Firestore (visitors, passes, approvals)
  • Firebase Cloud Messaging (approval requests)
  • Room (offline entry queue)
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 WhatsApp number — the synopsis PDF downloads immediately. We may send occasional project updates on WhatsApp; no spam.

Get a quotation