The context: Pimpri Chinchwad College of Engineering (PCCoE) runs an institutional ERP system for managing student academic records. While the ERP held attendance data, it offered no useful way to actually consume it — students had to log in, navigate three layers deep into the portal, locate each subject individually, and manually add up numbers on a calculator to understand where they stood. Every single day.
The problem: For a student managing six or seven subjects, understanding their attendance situation was a multi-minute manual exercise repeated daily — more often when exam season approached and the stakes got higher. There was no aggregated view, no subject-level breakdown at a glance, no way to know how many more lectures they could miss before falling below the required threshold, and no sense of where they'd end up by semester's end.
The ERP had the data. It just made it nearly inaccessible in any practical sense.
Specific pain points:
- Three-level deep navigation just to reach the attendance section — login, dashboard, academics, attendance — for every individual subject.
- No calculated totals — the portal showed raw numbers, not percentages, requiring manual arithmetic per subject per visit.
- No predictive context — students had no way to know how many lectures they could afford to miss, or where their attendance would land by semester end based on current trajectory.
- No unified view — there was no single screen showing all subjects together with meaningful context.
The solution: Built a mobile-first attendance intelligence platform in Flutter, backed by a Python Flask API deployed on Azure, that gives a PCCoE student their complete, calculated, analytics-rich attendance picture in under 10 seconds — from opening the app to seeing everything.
The core of the platform required mapping PCCoE's ERP auth flow and undocumented internal API endpoints through systematic discovery using browser developer tools and network traffic analysis. Once the integration layer was established, the Flask backend handled secure credential proxying, data aggregation, and the analytics computation — freeing the Flutter frontend to focus entirely on presenting a clean, unified view that the ERP never offered.
Within 24 hours of release, the app had been used over 2,500 times across the college — organic adoption driven entirely by students sharing it with each other, with no formal announcement.
The platform was built around three things the ERP never provided:
- Instant aggregation — all subjects, calculated percentages, in one screen, in one tap.
- Actionable analytics — how many lectures can I miss? How many do I need to attend? Where will I end up by semester end?
- Unified intelligence — everything a student needs to make daily attendance decisions, in a single view.
The Flutter app authenticates via the Flask backend on Azure, which maps the ERP's internal auth flow and API endpoints to retrieve raw attendance data. The backend computes aggregates, predictions, and analytics before returning a structured response to the app.
- Frontend: Flutter (cross-platform mobile)
- Backend: Python, Flask
- Cloud: Microsoft Azure
- Integration: ERP API endpoint discovery, auth flow analysis
- Analytics: Attendance aggregation, threshold calculations, semester-end predictions
The ERP exposed no public API and had no official integration mechanism. Through systematic analysis of the portal's network traffic and browser developer tools, we mapped the internal authentication flow and the undocumented API endpoints the web portal used to fetch attendance data. The Flask backend replicates this flow securely — handling credential authentication on behalf of the student, retrieving the raw per-subject data, and abstracting the ERP's inconsistent internal structure into a clean, consistent API that the Flutter frontend could reliably consume. This integration layer is the technical foundation the entire platform sits on, and getting it right required both security understanding and careful reverse engineering of the ERP's session management behaviour.
Raw attendance numbers from the ERP are useful; context around those numbers is what students actually need. The Flask backend computes three layers of analytics on top of the raw data:
- Current percentage per subject — calculated and ranked so students immediately see which subjects need attention.
- Lectures-to-safe-attendance — how many more lectures a student needs to attend (or can afford to miss) to stay above the required threshold for each subject.
- Predicted end-of-semester attendance — a projection based on current attendance rate and remaining lectures, giving students a forward-looking view rather than just a snapshot.
All three computations happen server-side before the response reaches the app, keeping the Flutter client lightweight and the analytics logic testable and maintainable in one place.
The design principle was simple: everything a student needs on one screen, readable in seconds. The Flutter frontend presents all subjects aggregated with their calculated percentages, colour-coded against the safe attendance threshold, alongside the predictive analytics — replacing a three-level navigation tree and a calculator with a single glanceable view. Flutter's cross-platform nature meant the app ran on both Android and iOS without a separate codebase, which mattered for college-wide adoption across a mixed device ecosystem.
The Flask backend was deployed on Azure, handling credential proxying and data aggregation at scale. Deploying on cloud infrastructure rather than a local or college server meant the platform stayed available as usage spiked — which proved critical given the 2,500+ sessions in the first 24 hours. Security was central to the design: the backend never persists student credentials, handling authentication transiently per request to minimise exposure surface.
- 2,500+ sessions in 24 hours — entirely organic adoption, student-to-student, with no formal announcement or promotion. The speed of spread across the college validated that this was a real problem with a real audience.
- 10-second time to insight — from opening the app to seeing fully calculated, analytics-rich attendance across all subjects, replacing a process that previously took several minutes of manual navigation and calculation.
- Three layers of navigation eliminated — the platform collapsed a multi-step daily ritual into a single screen, removing the friction that made the ERP's attendance data practically inaccessible for everyday use.
- Predictive context added — students gained forward-looking attendance intelligence the ERP never offered: lectures needed, lectures available to miss, and end-of-semester projections — turning raw data into actionable decisions.
- College-wide reach — the platform served students across all departments and years, demonstrating real-world scalability under unplanned load from day one.
Collaborative project built with equal contributors at Pimpri Chinchwad College of Engineering. Demonstrates practical integration engineering, backend analytics, mobile development, and cloud deployment skills.