Web-Based Automated Code Evaluation and

Grading
submitted in partially fulfilment of the requirements for the degree of

i
 DECLARATION
I hereby declare that the thesis entitled “Web-Based Automated Code Evaluation and
Grading System” submitted by me, for the award of the degree of.
I further declare that the work reported in this thesis has not been submitted and
will not be submitted, either in part or in full, for the award of any other degree or
diploma in this institute or any other institute or university.

\ Signature of the Candidate

ii
 CERTIFICATE

This is to certify that the thesis entitled “Web-Based Automated Code Evaluation and
Grading System” the award of the degree of Bachelor of Technology in Electronics and
Communication Engineering, is a record of bonafide work carried out by me under my
supervision, as \

The contents of this report have not been submitted and will not be submitted
either in part or in full, for the award of any other degree or diploma in this institute or
any other institute or university. The thesis fulfils the requirements and regulations of the
University and in my opinion meets the necessary standards for submission.

Place: Greater Noida

\
The thesis is satisfactory / unsatisfactory

Internal Examiner 1 Internal Examiner 2

Approved by
Head of the Department

iii
 ABSTRACT

The Automated Code Grading Portal is a web-based evaluation system designed to

automate the assessment of programming assignments submitted by students.
Traditional manual grading methods are time-consuming, inconsistent, and often
unable to provide timely feedback. This system addresses these issues by allowing
students to submit code through an intuitive interface, after which the backend
automatically executes the code against predefined test cases. The platform ensures
objective grading, instant result generation, and reduction of faculty workload,
making it highly suitable for academic institutions with large student enrollments.

The portal is developed using [Link] for the frontend, providing a responsive and
user-friendly interface, and [Link] with [Link] for backend API services. A
secure execution environment processes student submissions, compares actual
outputs with expected results, and assigns scores automatically. The system includes
functionalities such as assignment creation, test case management, submission
tracking, real-time evaluation, and performance analytics. This integration of modern
web technologies with automated testing mechanisms demonstrates the potential of
scalable digital systems in transforming academic assessment workflows.

Overall, the Automated Code Grading Portal enhances transparency, accuracy, and
efficiency in programming evaluation. It enables instructors to monitor student
progress, identify common mistakes, and refine teaching strategies based on
analytical insights. For students, the system provides immediate feedback, enabling
iterative learning and improvement. The project successfully validates the feasibility
of implementing an automated, fair, and extensible grading system that can be
expanded to support multiple programming languages, plagiarism detection,
advanced analytics, and large-scale adoption in educational institutions.

iv
\ Date:

TABLE OF CONTENTS
CHAPTER CONTENTS
NO.

Title Page

Declaration

Certificate

Abstract

Acknowledgement

Table of Contents

1 Introduction
1.1 Project Overview

1.2 Background and Motivation

1.3 Objective

1.4 Problem Statement

1.5 Scope Of the Project

v
 1.6 Summary

2 Traditional Methods of Programming

Assignment Evaluation
2.1 Introduction

2.2 Traditional Methods of Programming

Assignment Evaluation
2.3 Existing Automated Code Grading Systems

2.4 Comparative Study of Online Coding Platforms

2.5 Summary

3 System Analysis
3.1 Introduction

3.2 Existing System and Its Limitations

3.3 Proposed System

3.4 System Requirements

3.5 Summary

4 SYSTEM DESIGN & ARCHITECTURE

4.1 Introduction

4.2 System Architecture

4.3 Module Design

4.4 Summary

5 Result and discussion

5.1 Introduction

5.2 System Results

5.3 Performance Analysis

vi
 5.4 Discussion

5.5 Summary

6 Conclusion

References

7
 CHAPTER 1
INTRODUCTION
The rapid growth of computer science and engineering education has significantly
increased the reliance on programming assignments as a means to assess student
understanding and practical problem-solving skills. Traditionally, these assignments
are evaluated manually by instructors, which requires execution of each student's
code, verification of outputs, and assessment of logical correctness. As class sizes
grow, manual grading becomes increasingly time-consuming, inconsistent, and prone
to subjectivity. These limitations impact both instructors—who face increased
workload—and students, who often receive delayed feedback, hindering their
learning and progress.

Advancements in automation and web-based technologies have created opportunities

to streamline this evaluation process. An automated system provides instant execution
of submitted programs, objective scoring based on predefined criteria, and immediate
feedback that helps students learn more effectively. Automated code grading
platforms eliminate human errors, maintain consistency in evaluation, and support
high scalability, making them particularly useful in academic environments where
hundreds of submissions may need to be evaluated within short timeframes. Such
systems also help instructors identify common mistakes and trends across student
submissions, enabling richer data-driven insights into classroom performance.

The Automated Code Grading Portal developed in this project is designed to

address these challenges by offering a secure, efficient, and user-friendly platform for
submitting and evaluating programming assignments. Built using modern web
technologies such as [Link] for the frontend and [Link]/Express for backend
processing, the portal executes student code inside a controlled environment,
compares outputs with predefined test cases, and generates real-time scores. The
system reduces manual workload, enhances transparency, and promotes iterative
learning by giving students instant results. Overall, this project demonstrates how
automation can significantly improve the effectiveness and efficiency of
programming education in modern academic institutions.

8
1.1 Project Overview

The Automated Code Grading Portal is a web-based system designed to streamline

and automate the evaluation of programming assignments in academic environments.
The system allows students to upload their code, which is then executed securely and
evaluated against predefined test cases. Based on the correctness of the output and
defined evaluation metrics, the platform automatically assigns a score and provides
real-time feedback. This eliminates the dependency on manual grading and introduces
a consistent, unbiased, and scalable method of assessment.

The system integrates multiple modules including user authentication, assignment

creation, test case management, code execution, result computation, and student
performance tracking. Its architecture leverages modern web technologies, with
[Link] powering the frontend interface for an intuitive user experience and [Link]
handling backend logic and execution workflows. The portal is built to support
classroom-sized and institution-level deployments, offering the flexibility to integrate
additional functionalities such as plagiarism detection, multiple language support, and
analytics dashboards.

9
1.2 Background and Motivation

Programming education, especially in engineering institutions, requires frequent

evaluation of student assignments to ensure conceptual understanding and hands-on
practice. However, manual grading poses several challenges such as inconsistency,
subjectivity, long evaluation times, and limited feedback. As class sizes increase and
the curriculum becomes more outcome-driven, institutions are compelled to adopt
solutions that provide efficient, fair, and scalable assessment mechanisms. This need
has motivated the development of automated code grading systems capable of
evaluating large volumes of submissions without compromising accuracy or fairness.

In addition, modern learning environments demand instant feedback so students can

learn from their mistakes and iteratively improve their coding skills. Traditional
grading methods rarely support quick turnaround times, leaving students without
timely guidance. Automated evaluation systems help bridge this gap by executing
submitted programs immediately and providing actionable insights. The motivation
for this project, therefore, stems from the combined need for accuracy, speed,
transparency, and enhanced learning outcomes in programming education.

1.3 Objective

The primary objective of the Automated Code Grading Portal is to design and
implement a robust, scalable, and user-friendly system capable of evaluating
programming assignments automatically. The portal aims to reduce faculty workload,
ensure consistency in grading, and offer instant, objective feedback to students. By
automating repetitive tasks, instructors can allocate more time to conceptual teaching
and personalized student support.

Specific objectives of the project include:

 Developing an efficient submission and evaluation workflow using modern web

technologies.

 Implementing a secure and isolated environment for executing student code.

 Providing faculty members with tools to create assignments, set test cases, and
monitor performance.
10
 Allowing students to submit solutions, view results, and track progress over time.

 Ensuring that the system is extensible to support additional programming

languages, more complex evaluation logic, or external integrations.

Through these objectives, the project seeks to enhance the quality of assessment while
maintaining reliability and operational efficiency.

1.4 Problem Statement

The current manual evaluation process for programming assignments suffers from
several limitations that hinder effective learning and academic productivity.
Evaluating code manually is labor-intensive and time-consuming, especially when
dealing with large class sizes. Instructors must read, analyze, and execute each
student's submission, often repeating the same test cases multiple times. This not only
slows down the feedback loop but can also lead to inconsistency due to human error
or subjective interpretation.

Students, on the other hand, do not receive immediate feedback, which delays their
ability to identify mistakes and improve their coding skills. In fast-paced academic
environments, this delay can negatively impact learning outcomes. Additionally,
manual grading offers limited scalability and is prone to biases, making it unsuitable
for institutions that prioritize transparency and standardized evaluation practices.
These challenges highlight the need for an automated solution that can ensure
accurate, unbiased, and efficient grading.

1.5 Scope of the Project

The scope of this project includes the design, development, and testing of a complete
online code grading system. The portal provides functionalities for both students and
faculty members. Faculty users can create programming assignments, define test
cases, and review submissions. Students can submit their code through an integrated
editor or file upload feature, receive instant evaluation, and track historical
performance. The system also maintains detailed submission logs and result analytics
to help instructors assess overall class performance.

While the current prototype focuses primarily on Python-based submissions, the

11
architecture is modular enough to incorporate additional languages such as C, C++,
and Java. The project scope includes secure code execution through sandboxing
techniques to prevent malicious code from affecting the server. Future scope also
extends to implementing plagiarism detection algorithms, generating automated
feedback, and providing advanced dashboards for institutional reporting. Thus, while
the present scope delivers a fully functional evaluation system, it lays the foundation
for future scalability.

1.6 Summary

This chapter introduced the Automated Code Grading Portal, outlining the
motivation, objectives, challenges, and scope of the project. The need for efficient and
unbiased grading mechanisms in programming education serves as the primary
driving force behind this work. By leveraging automated evaluation techniques and
modern web technologies, the portal aims to deliver a scalable and impactful solution
for academic institutions.
The subsequent chapters of this report will delve deeper into the literature review,
system analysis, architectural design, implementation details, testing methodologies,
results, and conclusions. Through this structured approach, the report presents a
comprehensive understanding of how automated code grading can transform the
educational assessment landscape.

12
 CHAPTER 2
LITERATURE REVIEW

2.1 Introduction
The rapid growth of computer science education has led to increased reliance on
programming assignments as a core method of assessing student understanding and
problem-solving skills. As institutions shift toward outcome-based education,
continuous and accurate evaluation of programming tasks becomes essential.
Literature highlights the importance of timely feedback, objective scoring, and
scalable assessment methods to support large classrooms and diverse learning
environments. This need has encouraged researchers to explore automated grading as
a viable solution to modern academic challenges.

The concept of automated assessment is well-established in computer-based education

research, especially in the domain of e-learning and intelligent tutoring systems.
Studies emphasize the role of automation in reducing instructor workload while
improving the consistency and reliability of grading. Unlike traditional assessments,
automated systems apply uniform evaluation criteria, leading to more transparent and
data-driven academic decision-making. This aligns with global trends toward digital
transformation in educational institutions.

Existing research also suggests that incorporating automated evaluation systems

enhances student engagement and encourages iterative learning. When students
receive instant feedback, they are more likely to identify errors quickly, correct them,
and reinforce learning through active experimentation. This pedagogical advantage
has made automated grading an important area of interest in both academia and
industry, forming the foundation for the development of modern code grading
platforms.

13
2.2 Traditional Methods of Programming Assignment Evaluation

Historically, programming assignments have been evaluated manually by faculty

members who review the logic, structure, and output of each student's solution. While
this method allows instructors to observe individual coding styles and logic, it is
highly time-consuming and inefficient, particularly for large classes. The manual
approach often involves repeatedly compiling and running multiple submissions,
which increases the potential for evaluator fatigue and oversight. Literature identifies
manual grading as a major bottleneck in programming courses.

Moreover, manual evaluation introduces subjectivity into the grading process.

Different instructors may apply varying standards when assessing code quality,
efficiency, and correctness. This inconsistency can lead to fairness concerns and
dissatisfaction among students. Academic studies consistently report that subjective
grading diminishes students’ trust in the assessment process, making it difficult to
maintain standardization across different sections or instructors.

Another major limitation identified in the literature is the delay in providing feedback.
Students often wait days or weeks to receive evaluation results, which interrupts the
learning cycle. Research shows that timely feedback is critical for skill development
in programming courses, as students rely on error identification to progress. Thus,
traditional manual grading proves insufficient for meeting the demands of modern
computer science education and highlights the need for automated, efficient
alternatives.

2.3 Existing Automated Code Grading Systems

Researchers have developed several automated grading systems aimed at

reducing manual workload and increasing grading accuracy. Early academic
tools such as Web-CAT, AutoLab, and Mooshak introduced structured
evaluation models where student submissions were automatically tested
against predefined inputs and outputs. These systems demonstrated the
feasibility of automation but required significant setup and maintenance,
14
limiting their adoption in smaller institutions. Despite their complexity, they
laid the groundwork for modern evaluation systems.

In parallel, commercial coding platforms like HackerRank, CodeChef, and

LeetCode introduced advanced automated execution environments for
competitive programming. Although primarily designed for skill assessment
rather than academics, these platforms showcased scalable test-case execution,
real-time evaluation, and multi-language support. Researchers studying these
tools noted the importance of sandboxing techniques, time limits, and secure
environments to prevent malicious execution and ensure fair assessment.

However, the literature also highlights certain gaps in existing solutions,

especially when applied to academic settings. Most platforms do not support
customized rubric-based grading, institutional reporting, assignment lifecycle
management, or integration with learning management systems. Additionally,
many systems are proprietary, costly, or lack the flexibility needed for
university-specific requirements. These limitations justify the need for
institution-friendly, customizable solutions like the Automated Code Grading
Portal developed in this project.

15
2.4 Comparative Study of Online Coding Platforms

Online coding platforms have popularized automated code evaluation by offering interactive
programming environments, extensive problem libraries, and immediate feedback systems.
Platforms such as HackerRank and LeetCode utilize robust automated judging engines that
compare user outputs with expected results under strict runtime and memory constraints.
Literature acknowledges their contribution to enhancing programming proficiency, yet their
primary focus remains competitive programming rather than academic evaluation.
A comparative review reveals that while commercial platforms excel in scalability,
efficiency, and multi-language support, they lack essential academic features such as
assignment scheduling, student progress tracking, custom test-case creation, and instructor
dashboards. Researchers argue that academic institutions require more control over
assignment structure, grading schemes, and evaluation parameters—features typically
unavailable in competitive coding environments. This differentiation highlights the gap
between industry platforms and academic systems.
Additionally, several studies indicate that commercial platforms do not provide insights into
students' thought processes or partial correctness evaluations. Academic grading often
considers code structure, logic clarity, documentation, and coding style—dimensions not
captured solely through output matching. Therefore, while online coding platforms provide
strong foundations for automated evaluation, they do not fully address the academic
requirements that systems like the Automated Code Grading Portal are designed to fulfill.

2.5 Summary

The literature clearly establishes the need for automated evaluation systems in
programming education due to the limitations of manual grading and the growing
demand for scalable assessment tools. Research consistently highlights the benefits of
automation, including reduced evaluator workload, instant feedback, and standardized
grading mechanisms. Academic and commercial systems provide valuable insights
into automated assessment strategies, yet each exhibits limitations in terms of
flexibility, cost, or academic suitability.

Existing tools demonstrate strong capabilities but often lack customizable assignment
management, institution-specific grading policies, and classroom-level analytics.

16
These shortcomings reveal an opportunity for developing a tailored solution that
bridges the gap between academic needs and technological capabilities. The literature
therefore validates the motivation for creating an Automated Code Grading Portal that
offers reliability, scalability, and academic alignment.

In conclusion, Chapter 2 establishes the research foundation for this project by

examining existing methods, identifying their limitations, and highlighting gaps that
the Automated Code Grading Portal aims to address. This creates a strong
justification for the system’s design and development, which is detailed in the
following chapters.

17
 CHAPTER 3
SYSTEM ANALYSIS AND
DESIGN
3.1 Introduction
System analysis is a critical phase in software development where the problem
domain is studied in depth to understand the operational challenges, user needs, and
technical constraints. For the Automated Code Grading Portal, system analysis
enables a structured breakdown of existing academic workflows related to assignment
submission and evaluation. This process helps identify inefficiencies in traditional
manual grading practices and highlights opportunities where automation can bring
significant improvements. By thoroughly analyzing the problem space, it becomes
possible to define system objectives clearly and build a solution that addresses real
institutional needs.

In this project, system analysis also plays an important role in ensuring that the
architecture and functionalities align with scalability, usability, and security
requirements. A code grading system must handle multiple concurrent submissions,
execute potentially unsafe code securely, and provide deterministic evaluation results.
These characteristics make the analysis phase especially important, as it establishes
the technical groundwork needed to support such functionality. The success of the
proposed system depends on identifying precise specifications and constraints early in
the development process.

Furthermore, system analysis helps differentiate between essential system

requirements and additional features that can be included in later expansions. By
outlining both functional and non-functional requirements at this stage, developers
gain a comprehensive understanding of what must be achieved for version 1.0 of the
system. This systematic approach ensures that the final product is robust, reliable, and
capable of delivering measurable improvements over the existing system.

3.2 Existing System and Its Limitations

18
The existing system for evaluating programming assignments in most academic
institutions relies heavily on manual grading. Instructors typically download student
submissions, execute them individually, verify outputs, and assign marks based on
correctness and coding style. This process is repetitive and time-consuming,
especially in courses with large student enrollments. Manual evaluation also makes it
difficult to maintain consistent grading standards across multiple batches or
instructors, leading to inconsistencies that affect fairness and student satisfaction.
Another major limitation of the existing system is the delay in providing feedback.
Students usually receive grading results days or even weeks after submission, which
affects their ability to learn from mistakes and make improvements. Programming
education relies strongly on iterative learning, and delayed feedback disrupts this
cycle. Research has shown that timely feedback significantly improves learning
outcomes, making the lack of instant evaluation a serious drawback of manual
grading.
Moreover, manual systems offer very limited analytics or insights. Instructors cannot
easily identify common errors, track student performance trends, or analyze class-
wide understanding of specific concepts. There is also no centralized system for
managing submissions, test cases, or academic records. As a result, the current
approach not only increases instructor workload but also restricts opportunities for
data-driven decision-making. These limitations highlight the need for a system that
automates evaluation and enhances efficiency.

19
3.3 Proposed System

The Proposed Automated Code Grading Portal is designed to address the shortcomings of
manual grading methods by introducing a structured, automated, and efficient evaluation
workflow. The system allows instructors to create assignments and upload test cases, while
students can submit their code directly through a user-friendly interface. Once submitted, the
system automatically executes the code in a controlled environment, compares the output
with predefined expected outputs, and generates scores instantly. This automation ensures
fairness, consistency, and significant time savings for faculty members.
The system introduces a secure sandboxed execution environment to safely run untrusted
student code without risking damage to the server or interfering with other processes. This
ensures that even large numbers of submissions can be evaluated concurrently without
compromising security or performance. The system also logs each submission along with its
execution results, allowing instructors to review attempts, identify errors, and provide
additional feedback where needed. This structured approach supports both academic integrity
and pedagogical effectiveness.
Additionally, the proposed system enhances student learning by offering instant feedback and
enabling multiple attempts before deadlines. The interface provides a code editor, submission
previews, and result histories, empowering students to understand their mistakes and refine
their skills. Faculty members benefit from analytics dashboards that provide insights into
class performance, common mistakes, and assignment difficulty levels. Overall, the proposed
system is a scalable, user-friendly, and pedagogically sound solution for modern
programming education.

3.4 System Requirements

System requirements define the capabilities, constraints, and expectations of the Automated
Code Grading Portal. Functional requirements include features such as user authentication,
assignment creation, test case configuration, code submission, automated execution, and
score generation. These requirements outline what the system must do to meet user needs.
For example, students must be able to upload code in supported languages, and the system
must execute that code using predetermined input sets. The system should also maintain
submission histories and allow faculty to view detailed reports.

20
Non-functional requirements focus on quality attributes such as performance, reliability,
usability, and security. Performance requirements dictate that the system must evaluate
submissions within an acceptable time frame, even under heavy load. Reliability ensures that
grading outcomes must be consistent and reproducible. Usability requirements guarantee an
intuitive interface for both students and instructors, ensuring minimal training. Security
requirements involve sandboxing execution, validating inputs, and protecting data integrity.
In addition to these, scalability and maintainability are key considerations. The system should
support increasing numbers of students and assignments without compromising performance.
The codebase should be modular and extensible to allow future enhancements like multi-
language support, plagiarism detection, and automated feedback generation. Clearly defining
these requirements at the analysis stage ensures that the final system aligns with institutional
expectations and long-term academic use.

21
3.5 Summary

System analysis provides the foundation for designing an effective, scalable, and
secure code grading platform. By studying the challenges of the existing manual
grading process, this chapter identified the major inefficiencies that hinder both
student learning and instructor productivity. The limitations of traditional evaluation
methods make a strong case for adopting automated systems that offer objective,
fast, and reliable grading. The proposed system overcomes these barriers by
introducing structured workflows and automation mechanisms tailored to academic
settings.
Through a thorough analysis of system requirements, both functional and non-
functional needs have been clearly defined. These requirements ensure that the
Automated Code Grading Portal provides essential features like assignment creation,
automated execution, secure sandboxing, and instant feedback while also
maintaining quality attributes such as performance, reliability, and usability. The
system is designed to scale over time, supporting new features and technologies that
may be introduced in future versions.
This chapter establishes a comprehensive understanding of the system’s purpose,
strengths, and expectations. The insights gained from system analysis guide the
architectural and design decisions presented in the next chapter, ensuring a structured
and effective development process.

22
 CHAPTER 4
SYSTEM DESIGN & ARCHITECTURE

4.1 Introduction

System design is a crucial phase in software engineering where the

conceptual and technical foundations of a system are laid out. For the
Automated Code Grading Portal, this involves defining how different
system components interact, how data flows between modules, and
how the system ensures performance, reliability, and security. The
design phase transforms the requirements derived from system
analysis into a structured blueprint that guides the development
process. This minimizes ambiguity and ensures that the system is both
scalable and maintainable.

A well-designed system architecture is essential for handling core

functionalities such as automated code execution, test case evaluation,
real-time scoring, and secure sandbox management. Since the platform
must support multiple users submitting code simultaneously, it
requires a robust architecture that can efficiently manage processing
load while preventing system failures. The design decisions made at
this stage directly impact how well the system performs under real-
world academic workloads.

Moreover, system design ensures that each module of the portal—

frontend, backend, execution engine, and database—is clearly defined
with specific responsibilities. This modular approach enhances
flexibility and simplifies future updates, such as integrating additional
programming languages or advanced evaluation techniques. By
establishing clear architecture and module boundaries, the design

23
phase provides a solid technical foundation for the successful
implementation of the Automated Code Grading Portal.

4.2 System Architecture

The architecture of the Automated Code Grading Portal follows a

client–server model, comprising three major layers: the frontend
interface, backend services, and execution environment. The frontend,
built with [Link], serves as an interactive platform for students and
faculty, enabling assignment creation, submission uploads, and result
viewing. It communicates with the backend through RESTful APIs,
ensuring smooth, asynchronous interaction across the system. This
separation of concerns provides a responsive user experience while
maintaining code organization and clarity.

The backend, developed using [Link] and [Link], acts as the core
processing unit of the system. It handles user authentication,
assignment management, test case storage, and integration with the
execution engine. When a student submits code, the backend triggers
the evaluation workflow, passing the uploaded code and input test
cases to a secure sandbox environment. Once the code executes, the
backend compares the output with expected results and generates a
score accordingly. This architecture ensures consistency, accuracy,
and repeatability in evaluation.

The execution engine forms the most critical part of the architecture. It
runs student code in an isolated, controlled environment, preventing
harmful operations that could compromise server security. The system
can utilize technologies such as Docker-based sandboxes or [Link]
child processes for safe execution. This isolation ensures that each
submission is processed independently without interfering with other
system components. Altogether, the layered architecture provides
security, scalability, and efficiency—making it suitable for handling

24
large volumes of academic submissions.

4.3 Module Design

The system is divided into several modules, each responsible for

specific tasks to ensure smooth operation and clarity in design. The
User Module manages students and faculty interactions. It includes
functionalities such as login, registration, dashboard access, and role-
based permissions. Students can view assigned tasks, submit solutions,
and receive feedback, while faculty members can create assignments,
view submissions, and analyze student performance. This module
ensures proper authentication, authorization, and user management
across the platform.

The Assignment and Evaluation Module handles test case

configuration, submission processing, and scoring. It stores faculty-
defined input test cases and expected outputs, which serve as the basis
for evaluating student submissions. When code is submitted, this
module triggers the execution engine and retrieves output data from
the sandbox. It then compares the output to the expected results and
calculates the final score. This module is central to the system’s
purpose, ensuring objective and automated evaluation of programming
tasks.

The Execution and Data Management Modules ensure smooth

integration between code execution and persistent storage. The
Execution Module securely runs user-submitted programs, enforcing
memory and time limits to prevent system abuse. The Data
Management Module (backend database) stores all critical data,
including user profiles, assignments, submissions, and results. This
modular structure ensures maintainability, allowing developers to
update or extend individual modules without affecting the entire
system. Such a design supports future enhancements like adding new

25
languages, analytics dashboards, or plagiarism detection tools.

4.4 Summary

In this chapter, the system design and architecture of the Automated

Code Grading Portal were presented to demonstrate how the system is
structured to achieve efficiency, security, and scalability. The design
phase builds upon the analysis conducted earlier, ensuring that all
functional and non-functional requirements are effectively addressed.
By dividing the system into logical layers and modules, the
architecture maintains clarity while providing a robust foundation for
further development.

The architecture’s layered approach ensures separation of concerns,

enabling the frontend, backend, and execution environment to operate
cohesively while remaining independently maintainable. The secure
sandbox execution mechanism ensures that user code is evaluated
safely without compromising server integrity. Meanwhile, the
backend’s structured API framework supports efficient data handling
and communication between components, ensuring reliability and
responsiveness.

Finally, the modular design of the system ensures that new features
can be integrated seamlessly as the platform evolves. Whether
expanding language support, improving analytics, or enhancing user
experience, the established architecture supports continuous growth.
This chapter sets the stage for the implementation details discussed in
the next section, where the designed architecture is translated into
functional system components.

26
 CHAPTER 5
RESULT AND DISCUSSION

5.1 Introduction

The Results and Discussion chapter presents the outcomes of the

implementation and testing of the Automated Code Grading Portal.
This chapter evaluates the system’s effectiveness in performing
automated grading, its reliability under different conditions, and its
overall usability for students and faculty members. The purpose of
this section is to analyze how well the system meets the expectations
defined during the requirement and design phases, and to highlight
the strengths and limitations observed during evaluation.

Understanding the results is crucial because automated grading

systems must maintain accuracy, fairness, and security to be
considered viable alternatives to manual evaluation. The system was
tested using a variety of sample assignments and test cases to measure
grading accuracy, execution performance, scalability, and error-
handling capability. These experiments validate whether the
developed solution can successfully execute and evaluate diverse
programming submissions in a consistent manner.

This chapter also discusses user experiences and insights gained from
interacting with the portal. Observations from these evaluations help
identify areas of excellence as well as opportunities for future
enhancements. The goal is to present a clear, evidence-based
assessment of the system and discuss its practical impact on academic
workflows.

27
5.2 System Results

The Automated Code Grading Portal successfully met its primary objective of
automating programming assignment evaluation. Students were able to submit
their code through the intuitive web interface, and the system correctly
executed the submissions within the secure sandbox environment.
Assignments with multiple test cases were evaluated against each input-output
pair, and the system consistently produced accurate scoring results. These
outcomes confirm that the functional modules, including code execution,
output comparison, and scoring logic, operated as intended.

Faculty members were able to create assignments, define test cases, and view
submissions through the dedicated dashboard. The result logs generated for
each student allowed instructors to review submission history, observe errors,
and validate correctness. System testing revealed that the platform handled
consecutive submissions efficiently and maintained consistent behavior
regardless of the complexity of inputs. The correctness of evaluation results
was verified by comparing manually graded outputs with those produced by
the portal, showing high reliability.

Additionally, the system successfully generated real-time feedback for

students, enabling them to understand their mistakes and resubmit solutions
where allowed. This iterative approach mirrors professional coding evaluation
environments and significantly enhances learning. The results indicate that the
platform can serve as a practical academic tool that improves transparency,
speeds up evaluation, and reduces instructor workload.

28
5.3 Performance Analysis

Performance analysis was conducted to evaluate the speed,

responsiveness, and robustness of the system under typical usage
conditions. Code execution time remained consistently low for
standard Python assignments, with most submissions completing
evaluation within one second. The system also demonstrated stable
performance under multiple concurrent submissions, suggesting that
the backend architecture and execution engine are capable of handling
class-sized workloads. These results confirm that the application can
support real academic usage without performance degradation.

Server-side processing was tested by simulating multiple students

submitting code simultaneously. The system maintained acceptable
response times and correctly queued and processed submissions. This
indicates that the design choices—such as modular backend
architecture, isolated execution environment, and efficient API
communication—contribute positively to overall system performance.
Even under load, the portal maintained consistent evaluation outcomes
and did not encounter execution failures or timeouts.

From a frontend perspective, the React-based interface provided

smooth navigation and fast page loads, even when handling multiple
assignment entries and submission logs. The integration of
asynchronous communication (API calls) ensured that users
experienced minimal delays during interaction. Overall, the
performance analysis demonstrates that the system is optimized for
speed, reliability, and scalability, making it suitable for real-world
deployment in academic settings.

29
5.4 Limitations Observed

The results of the system evaluation highlight several key strengths of the
Automated Code Grading Portal. First, the platform significantly reduces the
time required for grading programming assignments by automating execution
and evaluation. This automation not only improves efficiency but also
enhances fairness, since test case-based evaluation eliminates human bias. The
system’s ability to provide instant feedback allows students to correct errors
quickly and promotes iterative learning, which is highly beneficial in
programming education.
Second, the modular architecture of the system ensures maintainability and
future scalability. The separation of frontend, backend, and execution engine
components enables developers to extend system functionality without
disrupting core operations. Features such as dashboard analytics, multi-
language support, or plagiarism detection can be added in later iterations.
These findings align with the goal of creating a flexible and extensible
academic tool that adapts to institutional needs.
However, the discussion also reveals certain limitations. The current version
primarily supports Python-based submissions and limited test case formats.
Additionally, resource-heavy programs or infinite loops may require more
advanced sandbox strategies to prevent overuse of system resources. Despite
these limitations, the system demonstrates strong potential and provides a
solid foundation for future enhancements that will further strengthen its
academic value.

5.5 Summary

This chapter presented the results obtained from system

implementation and testing, along with a detailed analysis of the
system’s performance and practical impact. The Automated Code
Grading Portal proved successful in accurately evaluating student
submissions, maintaining system stability, and providing timely

30
feedback. Tests confirmed that the platform performed reliably under
concurrent submission scenarios and maintained high responsiveness
across different modules.
Performance analysis showed that the system is efficient, scalable,
and suitable for academic environments where multiple students may
interact with the portal simultaneously. The integration of secure
sandbox execution ensures safe processing of untrusted code, while
the well-structured backend supports smooth communication across
all components. These results validate the effectiveness of the system
design and implementation strategies used.
In conclusion, the Automated Code Grading Portal has demonstrated
strong capability as an academic tool, offering significant
improvements in evaluation efficiency, accuracy, and student
engagement. The findings reinforce the importance of adopting
automated grading technologies in modern educational settings and
provide a clear pathway for future enhancements that can expand the
system’s scope and functionality.

31
 CHAPTER 6
CONCLUSION
The Automated Code Grading Portal successfully demonstrates how
automation can transform the evaluation of programming assignments
in academic environments. By implementing an efficient workflow
that includes assignment creation, secure code execution, automated
output comparison, and instant scoring, the system addresses the key
shortcomings of traditional manual grading methods. The project
shows that automated evaluation not only reduces instructor workload
but also enhances fairness, consistency, and transparency in the
assessment process. Through its modular design and modern web-
based interface, the portal provides an accessible and intuitive platform
for both students and faculty members.

The testing and analysis conducted throughout the project reveal that
the system performs reliably under various test conditions, including
multiple submissions, complex test cases, and concurrent user
interactions. The automated execution engine consistently produced
accurate and reproducible results, validating its effectiveness as an
academic evaluation tool. Students benefit from immediate feedback,
which supports iterative learning and improves problem-solving skills.
Faculty members gain access to structured submission logs and
performance data, enabling better monitoring of student progress and
identification of common errors.

Overall, the project achieves its objectives and demonstrates the

feasibility of implementing a scalable, secure, and robust automated
code grading system using modern web technologies. While the
current version focuses primarily on Python-based evaluation, the
system architecture provides ample scope for future enhancements
such as multi-language support, plagiarism detection, detailed

32
analytics dashboards, and deeper integration with institutional learning
management systems. The project contributes meaningfully to the
digital transformation of academic assessment and lays a strong
foundation for further innovation in automated learning technologies.

33
 REFERENCES

 Raj, R. & Kumar, S. "Automated Code Assessment Systems in Computer

Science Education", International Journal of Computer Applications, Vol.
182, No. 45, 2020.
 Douce, C., Livingstone, D., & Orwell, J. "Automatic Test-Based Assessment
of Programming: A Review", Journal of Educational Technology & Society,
2005.
 Ihantola, P., Ahoniemi, T., Karavirta, V., & Seppälä, O. "Review of Recent
Systems for Automatic Assessment of Programming Assignments",
Proceedings of the 10th Koli Calling International Conference on Computing
Education Research, 2010.
 HackerRank. Official Documentation. Available at:
[Link]
 LeetCode. Online Coding Platform Documentation. Available at:
[Link]
 [Link] Foundation. "[Link] Documentation", Available at: [Link]
 [Link] Community. "React Official Documentation", Available at:
[Link]

34