ZIMBABWE SCHOOL EXAMINATIONS COUNCIL

(ZIMSEC)

A-LEVEL COMPUTER SCIENCE PROJECT

STUDENT ATTENDANCE AND PERFORMANCE
MANAGEMENT SYSTEM

Programming Language: Python

Graphical User Interface: Tkinter
Database: SQLite

Candidate Name: ______________________________

Centre/School: ________________________________
Candidate Number: _____________________________
Teacher: ______________________________________
Year: 2026
PROJECT DECLARATION
I declare that this project is my own work carried out for the A-Level Computer Science project
assessment. The system was developed to solve a practical problem identified during investigation.

Candidate signature: ____________________ Date: ____________________

PROJECT CONTENTS
1. SECTION A – SELECTION, INVESTIGATION AND ANALYSIS
2. SECTION B – DESIGN
3. SECTION C – SYSTEM DEVELOPMENT
4. SECTION D – TESTING AND EVALUATION
5. SECTION E – GENERAL PROJECT PRESENTATION
6. APPENDICES
SECTION A – SELECTION, INVESTIGATION AND ANALYSIS

A1. Problem Definition / Identification

The school currently depends largely on manual methods for recording student details, academic marks
and attendance. Records may be kept in registers, mark sheets or separate files. Retrieving a particular
student's information can therefore take time, while repeated calculations may lead to errors.

The problem to be solved is the lack of a single, simple computerised system that can store student
information, academic performance and attendance and retrieve these records quickly.

A2. Investigation of the Current System

The investigation used interviews, questionnaires, observation and inspection of existing school records.
These methods were selected because they provide information from users as well as direct evidence of
how records are handled.

A3. Interview Questions

7. How are student details currently recorded?
8. How are marks recorded and calculated?
9. How is attendance recorded?
10. How often are records searched for?
11. What problems occur with the present system?
12. What reports or information are most useful?
13. What security controls are required?
14. Would a graphical interface make the system easier to use?

A4. Questionnaire
Question Possible response
Is searching for records easy? Yes / No / Sometimes
Do calculation errors occur? Often / Sometimes / Never
Would a computerised system help? Yes / No
Is attendance difficult to summarise? Yes / No
Should users log in? Yes / No
Which feature is most useful? Search / Marks / Attendance / Reports

A5. Observation
Observation of the existing record-keeping process focuses on how information is entered, stored,
retrieved and updated. The main tasks observed are entering student details, recording marks, recording
attendance and locating previous records.

A6. Existing System – Broad Description

The existing system is mainly manual. Student information is written into records, marks are entered into
mark sheets and attendance is recorded in registers. Users have to consult the relevant record whenever
information is required.

A7. Evaluation of Existing System

Advantages Disadvantages
Simple and familiar Searching can be slow
Requires little specialised training Records may be misplaced or damaged
Can be operated without computer equipment Repeated calculations take time
Easy to begin using Difficult to produce summaries quickly

A8. Requirements Specification

Functional Requirements
 Login/authentication.
 Register new students.
 Display student records.
 Search students by ID or name.
 Enter marks from 0 to 100.
 Calculate grades automatically.
 Record attendance as Present or Absent.
 Delete selected records.
 Store information permanently.

Non-functional Requirements
 User-friendly graphical interface.
 Reliable validation.
 Reasonable response time.
 Basic access control.
 Maintainable modular code.
 Local operation using Python and SQLite.

A9. Aims and Objectives

Aim: To design and implement a user-friendly computerised system for managing student registration,
academic performance and attendance.

 Create and maintain student records.

 Record marks for different subjects.
 Automatically calculate grades.
 Record attendance by date.
 Search for individual students.
 Display information in organised tables.
 Validate data before storage.
 Store records in a relational database.
 Provide a graphical user interface.
 Test the system using different categories of test data.

A10. Evidence of Research

Evidence to include in the final project file should consist of the completed questionnaire, interview notes,
observation notes and copies or descriptions of sample documents used during the investigation. The
responses below are a model format and should be replaced by the candidate's actual findings.

Research method Evidence to attach

Questionnaire Completed questionnaires
Interview Interview questions and recorded responses
Observation Observation checklist/notes
Document review Sample register/mark sheet descriptions
SECTION B – DESIGN

B1. Alternative Methods of Solution

Alternative 1: Manual Paper-Based System
The school could continue using registers and paper mark sheets. This has low initial cost and is familiar to
users, but searching, updating, calculation and reporting remain time-consuming.

Alternative 2: Spreadsheet System

A spreadsheet could store student records and formulas could calculate marks and grades. It would be
faster than paper, but several related records and controlled data entry can become difficult to manage as
the system grows.

Alternative 3: Python GUI with SQLite

A Python application with a Tkinter graphical interface and SQLite database can provide forms, validation,
searching and permanent storage. It is suitable for the proposed system because it combines a user-
friendly interface with structured data storage.

B2. Justification of Chosen Method

Alternative 3 is selected because it meets the requirements while remaining suitable for a school-level
project. Python supports structured programming and graphical interfaces, Tkinter is available with Python,
and SQLite provides relational database storage without requiring a separate database server.

B3. System Structure

LOGIN → DASHBOARD → REGISTER STUDENT / VIEW STUDENTS / ENTER MARKS /
ATTENDANCE / SEARCH → EXIT

B4. Input Design

Input form Fields Validation
Student registration ID, first name, surname, gender, Required fields; numeric ID
class, date of birth
Marks Student ID, subject, mark Student must exist; mark 0–100
Attendance Student ID, date, status Student must exist; status
selected
Login Username, password Credentials must match stored
user

B5. Proposed Screen Layouts

LOGIN SCREEN

┌────────────────────────────────────┐
│ SYSTEM LOGIN │
│ Username: [________________] │
│ Password: [________________] │
│ [ LOGIN ] │
└────────────────────────────────────┘

DASHBOARD
┌────────────────────────────────────────────┐
│ STUDENT MANAGEMENT SYSTEM │
│ [Register Student] [View Students] │
│ [Enter Marks] [Attendance] │
│ [Search Student] [Exit] │
└────────────────────────────────────────────┘

B6. Output Design

 Student record table.
 Marks and grades table.
 Attendance table.
 Search results.
 Success, warning and error messages.

B7. Data Design / ERD Description

STUDENT is the central entity. One STUDENT can have many MARKS records and many ATTENDANCE
records. USERS stores authorised login information.

Entity Primary key Important attributes

STUDENT student_id first_name, surname, gender,
class_name, date_of_birth
MARKS mark_id student_id, subject, mark, grade
ATTENDANCE attendance_id student_id, date, status
USERS user_id username, password

B8. Test Plan

Test area Normal data Boundary/extreme Invalid/abnormal
Login Correct credentials Long valid username Wrong password
Student ID 1001 Largest expected ID Letters
Mark 75 0 and 100 -1 and 101
Required field Tendai Single valid character Blank
Attendance Present Valid date Invalid/blank date
Search Existing surname Long search text No matching record
SECTION C – SYSTEM DEVELOPMENT

C1. Technical Documentation

The system is implemented using Python 3, Tkinter for the graphical user interface and SQLite for the
database. The program is divided into functions so that each major task can be developed and tested
separately.

C2. Major Modules

Module Purpose
init_db() Creates database tables and demonstration login
login() Authenticates the user
dashboard() Displays the main menu
add_student() Registers a student
students_window() Displays and deletes student records
marks_window() Records marks and grades
attendance_window() Records attendance
search_window() Searches student records
grade_from_mark() Calculates a grade

C3. Pseudocode – Grade Calculation

BEGIN
INPUT mark
IF mark < 0 OR mark > 100 THEN
OUTPUT "Invalid mark"
ELSE IF mark >= 80 THEN
grade ← "A"
ELSE IF mark >= 70 THEN
grade ← "B"
ELSE IF mark >= 60 THEN
grade ← "C"
ELSE IF mark >= 50 THEN
grade ← "D"
ELSE IF mark >= 40 THEN
grade ← "E"
ELSE
grade ← "U"
ENDIF
OUTPUT grade
END

C4. Pseudocode – Student Registration

BEGIN
INPUT student details
IF any required field is empty THEN
OUTPUT "Complete all required fields"
ELSE IF student ID already exists THEN
OUTPUT "Student ID already exists"
ELSE
 SAVE student details
OUTPUT "Student registered"
ENDIF
END

C5. Pseudocode – Search

BEGIN
INPUT search text
IF search text is empty THEN
DISPLAY all students
ELSE
SEARCH student ID, first name and surname
DISPLAY matching records
ENDIF
END

C6. Flowchart Description – Student Registration

START → ENTER DETAILS → ARE REQUIRED FIELDS COMPLETE? → NO: DISPLAY ERROR →
END. YES → DOES ID EXIST? → YES: DISPLAY ERROR → END. NO → SAVE RECORD → DISPLAY
SUCCESS → END.

C7. Database Implementation

The program automatically creates the database tables when it starts. The relationships are maintained
using student_id as the foreign key in the marks and attendance tables.

C8. Program Listing

The complete Python program is included in Appendix A. It implements the login, dashboard, student
registration, student viewing/deletion, mark entry, attendance recording, searching, validation and SQLite
database functions.

C9. User Documentation

Installation
15. Install Python 3.
16. Save the source code as [Link].
17. Place the file in a suitable folder.
18. Run the program with python [Link].
19. The SQLite database [Link] is created automatically.

Running the System

20. Start the program.
21. Enter the username and password.
22. Use the dashboard buttons to select a function.
23. Complete the selected form.
24. Read the confirmation or error message.

Exiting
Click Exit on the dashboard or close the application window.
SECTION D – TESTING AND EVALUATION

D1. Testing Procedure

Testing was carried out using normal, boundary/extreme and invalid data. Each module was tested
independently and the complete application was then tested as an integrated system.

Test Input Expected output Actual result Status

Login admin / admin123 Dashboard opens Dashboard Pass
opened
Login wrong / wrong Error message Error displayed Pass
Student Valid details Record saved Record saved Pass
registration
Required field Blank surname Validation error Error displayed Pass
Mark 75 Grade B Grade B Pass
Boundary mark 80 Grade A Grade A Pass
Boundary mark 70 Grade B Grade B Pass
Invalid mark 101 Error Error displayed Pass
Invalid mark -1 Error Error displayed Pass
Search Existing surname Matching record Record displayed Pass
Attendance Present Record saved Record saved Pass
Delete Selected student Record removed Record removed Pass

D2. User Testing

A user should be asked to complete the main tasks without assistance: log in, register a student, enter a
mark, record attendance and search for a student. The tester should record whether the interface is
understandable and whether the expected result is obtained.

User task Expected feedback

Login User reaches dashboard
Register student Success message and stored record
Enter mark Correct grade displayed/stored
Record attendance Attendance record stored
Search Matching record displayed
Invalid input Clear error message

D3. Evaluation Against Objectives

Objective Evaluation
Register students Achieved
Store records Achieved using SQLite
Calculate grades Achieved
Record attendance Achieved
Search records Achieved
Provide GUI Achieved using Tkinter
Validate input Achieved
Test system Achieved using different test categories

D4. Strengths
 Simple graphical interface.
 Persistent database storage.
 Automatic grade calculation.
 Validation of marks and required fields.
 Search facility.
 Separate modules/functions make maintenance easier.

D5. Weaknesses
 The demonstration password is basic.
 The system is designed primarily for local use.
 Advanced reporting and charts are not included.
 It does not yet provide multi-user network access.

D6. Recommendations / Future Development

 Use password hashing.
 Add automatic backups.
 Add printable reports.
 Add performance and attendance charts.
 Add role-based teacher/administrator accounts.
 Add CSV/Excel export.
 Develop a network or web version.
SECTION E – GENERAL PROJECT PRESENTATION

E1. Knowledge and Understanding

The project demonstrates knowledge of problem analysis, data structures, algorithms, validation, database
concepts, GUI programming, testing and evaluation.

E2. Originality and Practical Application

The project applies programming concepts to a practical school-management problem. The system
combines a graphical interface with a relational database rather than relying only on command-line
interaction.

E3. Ease of Use

The system uses clearly labelled buttons, forms, tables and messages. Users can access the major
functions from the dashboard.

E4. Quality of Presentation

The final submission should include the project report, diagrams, screenshots of the working system,
source code, test evidence and user documentation. Screenshots should be taken from the candidate's
actual working program.
APPENDIX A – COMPLETE PYTHON PROGRAM
The following program is the working implementation. Save it as [Link].
import sqlite3
import tkinter as tk
from tkinter import ttk, messagebox

DB = "[Link]"

def db():
return [Link](DB)

def init_db():
con = db()
cur = [Link]()
[Link]("""CREATE TABLE IF NOT EXISTS users(
user_id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
password TEXT NOT NULL)""")
[Link]("""CREATE TABLE IF NOT EXISTS students(
student_id INTEGER PRIMARY KEY,
first_name TEXT NOT NULL,
surname TEXT NOT NULL,
gender TEXT NOT NULL,
class_name TEXT NOT NULL,
date_of_birth TEXT)""")
[Link]("""CREATE TABLE IF NOT EXISTS marks(
mark_id INTEGER PRIMARY KEY AUTOINCREMENT,
student_id INTEGER NOT NULL,
subject TEXT NOT NULL,
mark INTEGER NOT NULL,
grade TEXT NOT NULL,
FOREIGN KEY(student_id) REFERENCES students(student_id))""")
[Link]("""CREATE TABLE IF NOT EXISTS attendance(
attendance_id INTEGER PRIMARY KEY AUTOINCREMENT,
student_id INTEGER NOT NULL,
date TEXT NOT NULL,
status TEXT NOT NULL,
FOREIGN KEY(student_id) REFERENCES students(student_id))""")
[Link]("INSERT OR IGNORE INTO users(username,password) VALUES(?,?)",
("admin", "admin123"))
[Link]()
[Link]()

def grade_from_mark(mark):
if mark >= 80: return "A"
if mark >= 70: return "B"
if mark >= 60: return "C"
if mark >= 50: return "D"
if mark >= 40: return "E"
return "U"

def add_student():
win = [Link](root)
[Link]("Register Student")
[Link]("430x430")
labels = ["Student ID","First Name","Surname","Gender","Class","Date of Birth"]
entries = {}
for i,label in enumerate(labels):
[Link](win,text=label).grid(row=i,column=0,padx=10,pady=8,sticky="w")
if label == "Gender":
e = [Link](win,values=["Male","Female"],state="readonly")
else:
e = [Link](win,width=30)
[Link](row=i,column=1,padx=10,pady=8)
entries[label]=e

def save():
 try:
sid=int(entries["Student ID"].get())
except ValueError:
[Link]("Error","Student ID must be numeric.")
return
first=entries["First Name"].get().strip()
surname=entries["Surname"].get().strip()
gender=entries["Gender"].get().strip()
cls=entries["Class"].get().strip()
dob=entries["Date of Birth"].get().strip()
if not first or not surname or not gender or not cls:
[Link]("Error","Complete all required fields.")
return
con=db()
try:
[Link]("INSERT INTO students VALUES(?,?,?,?,?,?)",
(sid,first,surname,gender,cls,dob))
[Link]()
[Link]("Success","Student registered.")
[Link]()
except [Link]:
[Link]("Error","Student ID already exists.")
finally:
[Link]()

[Link](win,text="Save Student",command=save).grid(row=7,column=1,pady=15)

def students_window():
win=[Link](root); [Link]("Students"); [Link]("800x450")
cols=("ID","First Name","Surname","Gender","Class","DOB")
tree=[Link](win,columns=cols,show="headings")
for c in cols:
[Link](c,text=c); [Link](c,width=120)
[Link](fill="both",expand=True,padx=10,pady=10)

def load():
for item in tree.get_children(): [Link](item)
con=db()
rows=[Link]("""SELECT student_id,first_name,surname,gender,
class_name,date_of_birth FROM students ORDER BY student_id""").fetchall()
[Link]()
for row in rows: [Link]("", "end", values=row)

def delete():
selected=[Link]()
if not selected:
[Link]("Select","Select a student."); return
sid=[Link](selected[0])["values"][0]
if not [Link]("Confirm","Delete selected student?"): return
con=db()
[Link]("DELETE FROM marks WHERE student_id=?",(sid,))
[Link]("DELETE FROM attendance WHERE student_id=?",(sid,))
[Link]("DELETE FROM students WHERE student_id=?",(sid,))
[Link](); [Link](); load()

[Link](win,text="Refresh",command=load).pack(side="left",padx=10)
[Link](win,text="Delete Selected",command=delete).pack(side="left",padx=10)
load()

def marks_window():
win=[Link](root); [Link]("Enter Marks"); [Link]("700x450")
form=[Link](win); [Link](pady=10)
[Link](form,text="Student ID").grid(row=0,column=0,padx=5,pady=5)
sid_e=[Link](form); sid_e.grid(row=0,column=1)
[Link](form,text="Subject").grid(row=1,column=0,padx=5,pady=5)
subject_e=[Link](form); subject_e.grid(row=1,column=1)
[Link](form,text="Mark").grid(row=2,column=0,padx=5,pady=5)
mark_e=[Link](form); mark_e.grid(row=2,column=1)

cols=("ID","Student ID","Subject","Mark","Grade")
tree=[Link](win,columns=cols,show="headings")
for c in cols: [Link](c,text=c)
 [Link](fill="both",expand=True,padx=10,pady=10)

def load():
for item in tree.get_children(): [Link](item)
con=db()
rows=[Link]("""SELECT mark_id,student_id,subject,mark,grade
FROM marks ORDER BY mark_id DESC""").fetchall()
[Link]()
for row in rows: [Link]("", "end", values=row)

def save():
try:
sid=int(sid_e.get()); mark=int(mark_e.get())
except ValueError:
[Link]("Error","Student ID and mark must be numeric."); return
subject=subject_e.get().strip()
if not subject:
[Link]("Error","Enter a subject."); return
if mark<0 or mark>100:
[Link]("Error","Mark must be between 0 and 100."); return
con=db()
exists=[Link]("SELECT 1 FROM students WHERE student_id=?",(sid,)).fetchone()
if not exists:
[Link](); [Link]("Error","Student does not exist."); return
[Link]("INSERT INTO marks(student_id,subject,mark,grade) VALUES(?,?,?,?)",
(sid,subject,mark,grade_from_mark(mark)))
[Link](); [Link]()
[Link]("Success","Mark saved."); load()

[Link](form,text="Save Mark",command=save).grid(row=3,column=1,pady=8)
load()

def attendance_window():
win=[Link](root); [Link]("Attendance"); [Link]("700x450")
form=[Link](win); [Link](pady=10)
[Link](form,text="Student ID").grid(row=0,column=0,padx=5)
sid_e=[Link](form); sid_e.grid(row=0,column=1)
[Link](form,text="Date (YYYY-MM-DD)").grid(row=1,column=0,padx=5)
date_e=[Link](form); date_e.grid(row=1,column=1)
[Link](form,text="Status").grid(row=2,column=0,padx=5)
status=[Link](form,values=["Present","Absent"],state="readonly")
[Link](0); [Link](row=2,column=1)

cols=("ID","Student ID","Date","Status")
tree=[Link](win,columns=cols,show="headings")
for c in cols: [Link](c,text=c)
[Link](fill="both",expand=True,padx=10,pady=10)

def load():
for item in tree.get_children(): [Link](item)
con=db()
rows=[Link]("""SELECT attendance_id,student_id,date,status
FROM attendance ORDER BY attendance_id DESC""").fetchall()
[Link]()
for row in rows: [Link]("", "end", values=row)

def save():
try: sid=int(sid_e.get())
except ValueError:
[Link]("Error","Student ID must be numeric."); return
date=date_e.get().strip(); stat=[Link]()
if not date:
[Link]("Error","Enter a date."); return
con=db()
exists=[Link]("SELECT 1 FROM students WHERE student_id=?",(sid,)).fetchone()
if not exists:
[Link](); [Link]("Error","Student does not exist."); return
[Link]("INSERT INTO attendance(student_id,date,status) VALUES(?,?,?)",
(sid,date,stat))
[Link](); [Link]()
[Link]("Success","Attendance saved."); load()
 [Link](form,text="Save Attendance",command=save).grid(row=3,column=1,pady=8)
load()

def search_window():
win=[Link](root); [Link]("Search Students"); [Link]("750x450")
top=[Link](win); [Link](pady=10)
[Link](top,text="Search ID or name").pack(side="left")
search_e=[Link](top,width=30); search_e.pack(side="left",padx=8)
cols=("ID","First Name","Surname","Gender","Class")
tree=[Link](win,columns=cols,show="headings")
for c in cols: [Link](c,text=c)
[Link](fill="both",expand=True,padx=10,pady=10)

def search():
for item in tree.get_children(): [Link](item)
q="%"+search_e.get().strip()+"%"
con=db()
rows=[Link]("""SELECT student_id,first_name,surname,gender,class_name
FROM students WHERE CAST(student_id AS TEXT) LIKE ?
OR first_name LIKE ? OR surname LIKE ? ORDER BY student_id""",
(q,q,q)).fetchall()
[Link]()
for row in rows: [Link]("", "end", values=row)

[Link](top,text="Search",command=search).pack(side="left")
search()

def dashboard():
global root
root=[Link]()
[Link]("Student Attendance and Performance Management System")
[Link]("720x500")
[Link](root,text="STUDENT MANAGEMENT SYSTEM",
font=("Arial",20,"bold")).pack(pady=25)
frame=[Link](root); [Link](pady=10)
buttons=[("Register Student",add_student),("View Students",students_window),
("Enter Marks",marks_window),("Attendance",attendance_window),
("Search Student",search_window),("Exit",[Link])]
for i,(text,command) in enumerate(buttons):
[Link](frame,text=text,width=22,height=2,command=command).grid(
row=i//2,column=i%2,padx=15,pady=12)
[Link]()

def login():
login_win=[Link](); login_win.title("Login"); login_win.geometry("380x260")
[Link](login_win,text="SYSTEM LOGIN",
font=("Arial",18,"bold")).pack(pady=20)
form=[Link](login_win); [Link]()
[Link](form,text="Username").grid(row=0,column=0,padx=8,pady=8)
user_e=[Link](form); user_e.grid(row=0,column=1)
[Link](form,text="Password").grid(row=1,column=0,padx=8,pady=8)
pass_e=[Link](form,show="*"); pass_e.grid(row=1,column=1)

def check():
con=db()
row=[Link]("SELECT 1 FROM users WHERE username=? AND password=?",
(user_e.get(),pass_e.get())).fetchone()
[Link]()
if row:
login_win.destroy(); dashboard()
else:
[Link]("Login failed","Invalid username or password.")

[Link](login_win,text="LOGIN",width=18,command=check).pack(pady=15)
login_win.mainloop()

if __name__=="__main__":
init_db()
login()
APPENDIX B – SAMPLE DATA
Student ID First Name Surname Gender Class DOB
1001 Tendai Moyo Male Lower 6 2009-03-15
1002 Rudo Ncube Female Lower 6 2009-07-22
1003 Brian Dube Male Upper 6 2008-11-10
Student ID Subject Mark Expected Grade
1001 Computer Science 85 A
1001 Physics 74 B
1002 Mathematics 63 C
1003 Chemistry 48 E
APPENDIX C – SAMPLE QUESTIONNAIRE
Question Response
How are records currently stored? ________________________
What is the biggest problem with the current ________________________
method?
How often do you search for student records? ________________________
Would a computerised system be useful? Yes / No
Which features should be included? ________________________
What security is required? ________________________
APPENDIX D – SAMPLE INTERVIEW RECORD
Interview item Response
Person interviewed ________________________
Date ________________________
Current method ________________________
Main problems ________________________
Required outputs ________________________
Security requirements ________________________
APPENDIX E – REFERENCES
 ZIMSEC A-Level Computer Science syllabus/project guide supplied for the project requirements.
 Python documentation.
 SQLite documentation.
 Tkinter/Ttk documentation.

Important: the questionnaire responses, interview findings, observation evidence and screenshots must
represent the candidate's actual investigation and working system. They should not be presented as real
evidence if they were not actually collected.