A student attendance app using face recognition with YOLO and OpenCV, plus a session timer that flags late arrivals, rejects outsiders, and exports attendees to Excel.
An academic project carried out by a team of students with technical assistance from Techno Enjaz to develop an application that records student attendance in lectures through face recognition, combined with a session timer that defines the allowed attendance window. A camera continuously captures frames of the classroom during the lecture; the system detects faces in them with the YOLO algorithm via the Ultralytics library, compares them with pre-stored student photos, and automatically records the name of every student it recognizes.
When the lecture ends, the application exports an Excel file listing the students present and their entry times. The system's rules mark anyone arriving after the allowed window as late or absent, refuse attendance for anyone not registered for that classroom, and clear the session data automatically in preparation for the next lecture. The project is a working prototype, and its report does not include quantitative measurements of recognition accuracy.
| Item | Details |
|---|---|
| Project type | Prototype attendance application based on computer vision |
| Field | Artificial intelligence, computer vision, face recognition, educational administration |
| Project status | Prototype implemented with a live recognition interface and Excel export |
| Techno Enjaz role | Technical support and assistance to the students during project development |
| Core technologies | Python, YOLO (Ultralytics library), OpenCV, Anaconda, Jupyter Notebook, Visual Studio Code |
| Outputs | Automatic recognition of student faces, attendance logged with entry time, Excel file of attendees |
Most educational institutions still record attendance with paper lists, roll calls, or handwritten signatures. These methods take up part of the lecture, are prone to human error such as forgetting or duplicating names, and allow manipulation through students signing on behalf of absent classmates. As student numbers grow, tracking absence and lateness by hand becomes an increasing administrative burden.
Cards, ID numbers, and fingerprint devices improve accuracy somewhat, but a card can be forgotten or lent, and, more importantly, many of these systems record attendance without regard to entry time: a student who arrives late may be marked present like everyone else. The project therefore set out to combine identity verification through facial biometrics with a time-based mechanism that distinguishes punctual students from late ones and blocks unauthorized registrations.
The project was carried out academically by the students, with technical assistance and support from Techno Enjaz during development. It is presented among the office's work as an example of its support for applied projects that use computer vision and face recognition to automate administrative processes.
The project set out a number of objectives, chiefly:
The project's workflow diagram describes the following processing sequence:
According to the scope described in the project, the system follows these rules:
| Rule | What happens |
|---|---|
| Allowed window | A student counts as present if the system recognizes them within the lecture's defined time window |
| Lateness | Anyone entering after the allowed time is automatically recorded as late or absent |
| Unregistered people | The system refuses attendance for anyone not registered in the classroom's database |
| End of lecture | Session data is cleared automatically to prepare for the next lecture without manual intervention |
| Tool | Role in the project |
|---|---|
| Anaconda | Package management and isolated virtual environments that avoid version conflicts |
| Visual Studio Code | Main editor for writing and debugging the code |
| Jupyter Notebook | Running the algorithms interactively and documenting each step with its results |
| OpenCV | Image processing, computer vision tasks, and camera handling |
| Ultralytics | Running recent YOLO versions for real-time face detection |
| Microsoft Excel | Output file containing student names and entry times |
The project's implementation chapter presents two main outputs:
These outputs demonstrate that the core pipeline works, from frame capture to the attendance file. However, the project reports no quantitative values of its own, such as correct-recognition rate, error rate, number of students tested, or processing time, so no specific accuracy figures are attributed to this version. The high accuracy figures quoted in the review of previous studies belong to other systems and are not results of this application.
The project itself sets out several constraints that frame its use:
According to the outlook set out in the project, the application could be developed through:
The system processes images of students' faces, which are sensitive biometric data. Any real deployment therefore needs clear consent from students, a definition of who may access the reference photos and attendance files, and a stated policy on how long they are kept and how they are protected.
If you are working on a face-recognition attendance app and need technical help developing the idea or building a prototype, you can contact the Techno Enjaz office to discuss your project's requirements and the appropriate scope of support.
It is a prototype built by a team of students with technical assistance from Techno Enjaz that records student attendance in lectures automatically by recognizing their faces through a camera. It combines identity verification with a timer that defines the allowed attendance window, then exports the list of attendees to an Excel file.
The system loads the YOLO model and the registered student photos, then continuously captures camera frames during the session and detects the faces in them. Detected faces are compared with the stored photos, each recognized student's name is saved with their entry time, and when the lecture ends an Excel file of attendees is exported.
A student counts as present if the system recognizes them within the lecture's defined window, and anyone entering after it closes is automatically recorded as late or absent. The system also refuses attendance for anyone not registered in the classroom's database and clears session data when the lecture ends, ready for the next one.
The project uses the YOLO algorithm through the Ultralytics library for real-time face detection and OpenCV for image processing and camera handling. Development was done in an Anaconda environment with Visual Studio Code and Jupyter Notebook, with attendance output to a Microsoft Excel file.
The project documents an interface that recognizes student faces and records attendance automatically, and an Excel file of attendee names and entry times, but it reports no quantitative recognition-accuracy measurements. The system works in closed classrooms with high-resolution cameras and suitable lighting, may struggle with masks or low light, and keeps no records after the lecture unless connected to an external archiving system.
Reach out to Techno Enjaz engineering team to discuss technical feasibility, prototype hardware, and development scope.
Discover more engineering prototypes and academic implementations
A virtual board for writing, drawing, picking colors and erasing with hand gestures in front of a camera, built in Python with MediaPipe hand tracking and OpenCV.
A prototype that detects people with YOLOv8 and tracks them with DeepSORT in defined work areas, counts presence time in seconds, and exports records to Excel.
An exam-monitoring prototype using YOLO, MediaPipe and OpenCV to analyze a student's head direction, flagging head turns in red for review and forward gaze in green.
