SM//SYSTEMS
2020 – 2021UI & API Integration Engineer (Team of 4)Matoshri Asarabai Polytechnic, Nashik

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.

VERIFIED DELIVERABLE IMPACT
+30%Attendance tracking efficiency improvement
CORE ARCHITECTURE STACK:
JavaAndroidJavaScriptREST APIs
01OPERATIONAL CHALLENGE & SCOPE

Problem Space & Architecture Ownership.

FAILURE MODE IN CENTRALIZED SYSTEMS

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.

ENGINEERING OWNERSHIP

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.

02DATA FLOW ARCHITECTURE

Deterministic Pipeline Flow.

Asynchronous mobile barcode acquisition pipeline with zero-latency in-memory deduplication and throttled REST synchronization.

INTERACTIVE SYSTEM TOPOLOGYDIPLOMA 85% CAPSTONE
SYSTEM TOPOLOGY // CLIENT DEDUPLICATION PIPELINE+30% THROUGHPUT
01 / SCANNERAndroid ClientJava · Camera02 / FILTER GATEDeduplication Gate60s Hash CacheDUPLICATE DETECTEDSuppressed Locally (0 HTTP)03 / ASYNC DISPATCHWorker QueueREST Client · Non-blocking04 / BACKEND LEDGERClassroom Session APITokenValid
INSPECT NODE:Click or hover any node above to inspect architectural contracts & deduplication logic.
01

Mobile Presentation

Native Java Android application featuring customized ZXing / barcode scanner surface view.

02

Validation Filter

In-memory hash set checking timestamped QR payloads to discard repeated scans in real time.

03

Networking Tier

Asynchronous HTTP REST client serializing JSON payloads for attendance ledger updates.

04

Backend Sync

REST API endpoints validating academic session windows and committing attendance state.

03IMPLEMENTATION ANALYSIS

Naive Baseline vs. Optimized Production Architecture.

Examine how state persistence and network concurrency were refactored for zero-regression stability.

android/app/src/main/AttendanceScanner.javaJava · Threading
Production Pattern: In-memory cooldown hash cache drops redundant camera scans instantly on the client, preventing network request flooding and database lock contention.
// 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 Baseline Flaw: Continuous 30 FPS camera sampling triggers dozens of concurrent HTTP POST calls for the same student badge, exhausting connection pools.
// 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() { ... });
}
04ENGINEERING DECISIONS & TRADEOFFS

Architectural Choices & Rigor.

DECISION 01

Constructed asynchronous background network workers in Java to prevent UI thread blocking during high-frequency barcode scanning bursts.

DECISION 02

Engineered strict client-side deduplication caching to immediately drop duplicate QR scans locally before transmitting requests over the network.

DECISION 03

Built streamlined, high-contrast UI screens optimized for rapid device camera focusing under variable classroom lighting conditions.

05VERIFIED DELIVERABLES

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.

ACADEMIC CAPSTONE RECORDDISTINCTION · 85.00%

"Student Attendance System via QR Code"

Matoshri Asarabai Polytechnic, Nashik · Diploma in Information Technology Capstone Project (Graduated 2021).

Native Android JavaClient-Side Deduplication+30% Logging Throughput
06DETAILED ARCHITECTURAL SPECIFICATION

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.
CONTINUE DOSSIER REVIEW · RESEARCH PUBLICATION (IRJMETS)

Blockchain-Based Secured Notarization System (BBSNS) ↗

Zero-trust cryptographic document notarization and verification platform.

⚡
ECO-ENGINE ACTIVE (-85% GPU)WebGL suspended · Animations halted · Minimal energy footprint