Student Attendance System via QR Code
High-throughput Android client application and REST API integration automating classroom attendance verification via dynamic QR code scanning and strict client-side validation.
Problem Space & Architecture Ownership.
Instructional Bottlenecks
Manual paper-based attendance logging in academic institutions causes significant instructional time loss, prone to proxy attendance, physical record damage, and delayed administrative record synchronization.
Shubham's Direct Responsibilities
Architected the Android interface flow, implemented asynchronous REST API communication routines, and engineered client-side validation filters to reject duplicate or malformed scans.
Deterministic Pipeline Flow.
Asynchronous mobile barcode acquisition pipeline with zero-latency in-memory deduplication and throttled REST synchronization.
Mobile Presentation
Native Java Android application featuring customized ZXing / barcode scanner surface view.
Validation Filter
In-memory hash set checking timestamped QR payloads to discard repeated scans in real time.
Networking Tier
Asynchronous HTTP REST client serializing JSON payloads for attendance ledger updates.
Backend Sync
REST API endpoints validating academic session windows and committing attendance state.
Naive Baseline vs. Optimized Production Architecture.
Examine how state persistence and network concurrency were refactored for zero-regression stability.
// Optimized Architecture: Client-side deduplication filter + throttled REST calls
public void onBarcodeScanned(String qrToken) {
long now = System.currentTimeMillis();
// 1. Drop redundant camera frames locally without generating network traffic
if (scanCache.containsKey(qrToken) && (now - scanCache.get(qrToken)) < 60000) {
Log.d("AttendanceEngine", "Redundant frame dropped in-memory (0ms network cost)");
return;
}
scanCache.put(qrToken, now);
// 2. Post atomic payload to REST API (+30% scan throughput gain)
apiService.recordAttendance(new AttendanceRequest(studentId, qrToken, now));
}// Naive Pattern: Unthrottled direct network writes per camera frame
public void onBarcodeScanned(String qrToken) {
// Flaw: Camera fires 30 fps; sends duplicate HTTP requests simultaneously,
// overwhelming backend connection pool and causing database deadlock
apiClient.postAttendance(studentId, qrToken, new Callback() { ... });
}Architectural Choices & Rigor.
Constructed asynchronous background network workers in Java to prevent UI thread blocking during high-frequency barcode scanning bursts.
Engineered strict client-side deduplication caching to immediately drop duplicate QR scans locally before transmitting requests over the network.
Built streamlined, high-contrast UI screens optimized for rapid device camera focusing under variable classroom lighting conditions.
Measurable System Outcomes.
Improved student attendance recording throughput by approximately 30% compared to traditional manual paper rosters.
Eliminated duplicate submission network traffic through client-side validation barriers.
Delivered responsive, zero-crash mobile interface validated across multiple Android OS versions.
"Student Attendance System via QR Code"
Matoshri Asarabai Polytechnic, Nashik · Diploma in Information Technology Capstone Project (Graduated 2021).
Engineering Breakdown & Technical Narrative.
System Overview
The Student Attendance System via QR Code is a streamlined mobile client and backend synchronization solution developed as an engineering capstone project at Matoshri Asarabai Polytechnic. The application replaces cumbersome, error-prone manual paper attendance sheets with instant, cryptographically verifiable QR code scanning on mobile devices.
The Operational Bottleneck
Classroom attendance tracking in high-density educational environments suffers from acute operational inefficiencies:
- Instructional Latency: Up to 10–15 minutes of lecture time is squandered on manual roll calls.
- Proxy Fraud: Paper sheets and manual signing enable attendance spoofing by peers.
- Data Latency: Paper records require manual transcription into institutional management systems, delaying absence tracking and reporting by days.
Engineering Implementation
1. High-Responsiveness Camera & Scanner Flow
The application leverages native Android camera integration to continuously sample and decode QR payloads. To maintain 60 FPS UI responsiveness, camera frame analysis runs on an isolated background thread, passing decoded tokens to the main thread via asynchronous message dispatchers.
2. Client-Side Deduplication & Validation
In dense classroom environments where multiple students scan within brief intervals, network floods and accidental double-scans can degrade backend performance. Shubham engineered an intelligent client-side debounce and cache mechanism:
- Each scanned payload includes a dynamic session identifier and timestamp.
- Scans are checked against an active in-memory cache; redundant tokens are rejected instantly without generating an HTTP request.
- Invalid or expired tokens trigger distinct visual feedback without crashing the camera scanner loop.
3. Asynchronous REST API Synchronization
Attendance data is packaged into structured JSON payloads and transmitted via asynchronous REST calls. The network pipeline gracefully handles intermittent connectivity, caching pending verifications and notifying the operator when synchronization completes.
Measurable Impact
- +30% Operational Throughput: Validated a ~30% time reduction in total attendance logging compared to manual roll call methods.
- Zero Duplicate Requests: Successfully filtered duplicate submissions locally prior to network transmission.
- Robust Field Performance: Deployed and tested across diverse Android device configurations with zero UI lockups during scanning operations.