DEV Community

Med Amine
Med Amine

Posted on

The Groundbreaking Schools Attendance Records Management System (ARMS)

Building ARMS – A better Attendance Records (or Record) Management System

Introduction

Hello everyone! I'm Mohammed the same dev of Xuploads, I’m excited to share a project I’ve been developing for quite some time — ARMS (Attendance Record Management System). It’s a system designed to streamline the way schools handle attendance, replacing the outdated, error-prone methods with a smarter, faster, and more reliable alternative.

This post covers the purpose, features, technical architecture, and some lessons learned along the way.

Why ARMS?

In many schools, attendance tracking is still handled manually — either using paper sheets or basic spreadsheets. That leaves a lot of room for mistakes, manipulation, and lost records. I’ve personally seen how chaotic it can get, especially when multiple classes are running in parallel or when attendance data is needed for reports.

The idea behind ARMS is to provide a centralized, secure, and intelligent system that schools can use to automate attendance tracking with as little friction as possible.

System Overview

ARMS is made up of three main parts:

  1. The ARMS API – A .NET Framework backend (ASP.NET) that handles all the logic for sessions, attendance records, authentication, logs, etc.
  2. The Desktop Application – A Windows-based GUI app built with VB.NET (Guna2 UI), used by administrators and staff to manage data, view attendance reports, and configure the system (works under WINE) with some UI bugs.
  3. The Attendance Devices – Can be mobile phones, Raspberry Pi, or any device capable of sending RESTful HTTP requests (via RFID, QR codes, or biometric input).

The system is multi-language (Arabic + English), internet-accessible, and multi-device-friendly.

Key Features

Here’s what ARMS currently offers:

  • Smart Session Handling: Teachers start class sessions, and the system marks all students absent by default. As students scan their ID (via RFID or QR), their attendance is corrected automatically.
  • Late Arrival Logic: Each subject has a customizable grace period. Arriving after that marks the student as late, not absent.

  • Role-Based Access:

    • Teachers only see their own sessions and classes.
    • Admins get full control over schedules, users, attendance logs, and exceptions.

  • Timetable Management: The school director can set schedules and assign classes and subjects to specific days and times.

  • Statistics & Reporting: Visual charts and detailed logs allow staff to see absence patterns and generate reports.

  • Parent Notification (in progress): Absence alerts will be sent to parents via email at the end of the day.

  • Device Management: Each attendance device can be assigned to specific classes. Devices can be enabled/disabled remotely.

  • Extension Support: ARMS supports an extension system using interfaces, so new features (like QR scanning, fingerprint support, etc.) can be added without changing the core logic.

  • Remote API: The API is secured and supports remote access, making it ideal for schools with limited local networking infrastructure.

Tech Stack

  • Backend: ASP.NET (.NET Framework)
  • Frontend (Admin): VB.NET WinForms (Guna UI 2)
  • Database: SQL Server (hosted locally or in the cloud)
  • Language Support: Arabic & English (fully switchable UI)
  • API Communication: JSON over HTTP (RESTful endpoints)
  • Architecture: Layered architecture with full async support on the API side

Under the Hood

  • Sessions are created by staff and linked to classes and subjects.
  • Attendance records are updated in real-time as students scan their RFID/QR/ID.
  • Every major action (session start, student scan, admin edit) is logged for audit purposes.
  • Extensions implement a common interface and can be loaded dynamically — for example, you could add a fingerprint scanner extension without modifying the API or desktop app.

Deployment & Updates

  • The Windows desktop app includes a built-in updater it called 'ARMSUpdater'. It pulls the latest version info from a server and displays changelogs before updating.
  • API rate limiting and logging are implemented to ensure performance and traceability.
  • All database operations are done asynchronously to avoid locking or bottlenecks.

Future Plans

  • Daily Attendance Summary Emails to parents
  • Student Self-Registration Mode
  • Third-party integrations (e.g., school management systems, Google Calendar)
  • Mobile Web Interface for teachers
  • Cloud-ready version with multitenancy support (for multiple schools on the same server)

Final Thoughts

ARMS has been a challenging but rewarding project. It's not just about tracking who showed up — it's about making school management more efficient, accountable, and modern. I've built it with real-world use in mind, based on feedback from actual school staff and administrators.

If you're working on similar systems or have ideas for improvements, I’d love to hear your thoughts!

GitHub & Demo

This is still a private project under active development, but I’m considering open-sourcing parts of it (like the extension system or attendance logic) once I clean them up.

Feel free to reach out if you're interested in contributing or testing it in a real-world environment.

Thanks for reading!

Let me know what you think in the comments.

Top comments (0)