A good software development education provides students with a combination of theoretical knowledge and practical experiences. However, preparing students for real-world development can be a challenge. Isolated assignments often fall short of adequately preparing students for a work setting where they will not only develop new software but also plan, improve and maintain existing systems throughout their lifecycle. Simulating the entire software development lifecycle is crucial, as it not only improves the students' skills but also better reflects the complexities of real-world software development. Furthermore, developers rarely work alone and must coordinate and communicate with their teams as well as customers. Curriculums often focus predominantly on technical knowledge and do not address the need for improving the students' collaboration and communication skills. As part of a course, we adopted an approach aimed at simulating the software development life cycle, where students planned, developed and iterated their Information System. To give the students the experience of developing in teams, while avoiding the pitfalls of group work and ensuring everyone acquired the necessary knowledge, we implemented a hybrid approach combining individual and group work. The goal of this paper is to share our approach and outline key findings and experiences.
There is a great demand for quality software developers and the fast pace of changes in tech requires
developers to constantly improve and acquire new knowledge [
Despite this, many university courses still rely on isolated programming tasks or final projects that
emphasize code production without simulating the full development lifecycle. As a result, students
may graduate with limited experience in areas such as requirement analysis, project planning, software
design, testing strategies, and deployment workflows [
In our course we adopted a hybrid approach, combining both individual and group assignments to ensure that each student independently acquired the necessary technical knowledge, while still benefiting from the experience of collaborative development. The goal of this paper is to share out approach and outline key findings and experiences.
The structure of this paper is as follows. In the next chapter, we briefly review related work in software engineering education, focusing on approaches that simulate real-world practices. Chapter 3 describes the course setup and the structure of assignments as well as how the SDLC was simulated. In Chapter 4, we analyze what worked well, what could be improved and list lessons learned. Chapter 5 contains the conclusion and ideas for future work.
Devedžić and Milenković [
Schroeder et al. [
Patani et al. [
Chen and Chong [
Bufardi [
Gitinabard et al. [
Overall, these studies show that simulating professional development in an educational settings requires a good balance between authenticity and working within the educational constraints. Prior work has shown that agile methods, structured communication, and industry-standard tools such as GitHub can significantly enhance both technical learning and teamwork, while also introducing new challenges related to time constraints, tool adoption, and assessment. A recurring theme across the literature is that students benefit most when courses not only expose them to technical practices but also collaboration and organization. Building on these insights, the following section describes how our course was designed to simulate the software development lifecycle and address some of the challenges identified in earlier work.
Our approach was implemented in the Development of Information Systems course, which is taught as part of the Bachelor’s study program Information and Data Technologies at the University of Maribor, Slovenia. It lasts 15 weeks and covers topics such as requirements analysis, planning, implementation, testing and automatization. Students are split into multiple lab groups where each group has labs once per week, lasting 135 minutes. Lectures last 90 minutes per week and are performed for all students at once.
To simulate the development of Information Systems from conception to completion, we split the work into 13 assignments. They were structured to gradually become more complex, allowing students to incrementally work on their projects while acquiring both technical and collaboration skills. The assignments were divided into individual and group tasks to ensure that each student understood the core concepts before moving on to group work. This was done to try to avoid the pitfall of group work where students do not contribute equally due to varying levels of skill. The collaborative part of the course was done in groups of 3, where students could freely choose the members of their teams. Allowing students to choose their own team members was done to ensure that they worked well together and were motivated to contribute to the team. Students who did not form their own teams were assigned teams by the teaching assistants (TAs).
For some group development assignments, we chose to use agile development methodologies, namely
Scrum and Kanban, as they are widely used in practice and a great fit for our team size and course
duration [
Individual assignments: 1. Environment set up: Each student was required to set up their working environment and create a project that works but does not yet contain any functionality. This assignment ensured that students had a working project setup and resolved any configuration issues before development began. Students could choose to implement a web application that was one of the following choices: TODO website, events website, travel planning website or a recipe website. The limited choice was implemented to ensure that the end results can be functionally comparable. They were however, not given a detailed specification but were expected to design the structure and functionality themselves within the chosen domain. 2. Database integration and CRUD operations: This assignment tasked students with creating an SQL database, connecting it to their project and implementing CRUD (Create, Read, Update, Delete) operations for their core functionalities. Additionally, students had to enhance their project by implementing a new feature of their choice.
The individual assignments provided each student with hands-on experience in setting up and implementing a basic application within a defined theme. Once group work began, each team selected one of their members’ individual projects as the foundation for collaborative development.
Group assignments: 3. Version control and collaboration using GitHub: Students divided into teams of 3 and were tasked with choosing a common project topic out of the previous individual assignments. They also needed to create their repository and necessary repository structure, as well as adding a README ifle, which includes a description of the project and its components, installation guide and common guidelines for developers working on the project. 4. Project planning and documentation: Students were required to describe their vision for the project and explain the purpose of the application, its aim and target audience. They also had to create a glossary of key terms used in their project domain and a use case diagram. 5. Additional functionality: Students were required to expand the use case diagram from the previous assignment and start preparing for the development of a new functionality. They had to provide a detailed description of each use case based on a template provided by the TAs. 6. Class diagram: Students were required to create a Class Diagram for their system. 7. Implementation: Students were required to implement all functionalities defined in the previous assignments, while ensuring each commit had a proper commit message and the README ifles were kept up to date. They were also instructed to keep issues up to date in their GitHub repository, using functionalities such as issue description, assignee, time estimates, milestones etc. 8. Unit testing and debugging: Students were required to perform unit testing for their backend functionalities and create a testing report with the test description and authors. 9. Agile methodologies - Scrum simulation: Students simulated Scrum development. Each group received a user story from the TAs, which they had to implement by the next class. They were required to break down the user story into tasks, estimate efort using planning poker and plan their sprint using an agile board on GitHub to help them plan and track progress. Finally, students were required to create a report containing development progress at the end of the week. 10. Agile methodologies - Kanban Simulation: In this assignment, students also received a user story from the TAs, which they had to implement, while following the Kanban methodology. During development the TAs asked for an update and sent the team new or updated requirements to simulate changes which the team had to adapt to. 11. Continuous Integration/Continuous Deployment (CI/CD): Students were required to set up a CI/CD (Continuous integration/delivery/deployment) pipeline which would automate building the project and running unit test including setting up the database if necessary. 12. Final Scrum simulation: The final assignment required students to simulate multiple roles in scrum development. Each team was paired by another team in the role of the client and the developer. As clients, the team members provided a description of the feature, which the developer team had to implement. After implementation, a presentation was made for their clients who then gave feedback and rated the development team based on their progress.
The assignments were structured to simulate as many stages as possible of the SDLC while still adhering
to the constraints of an educational setting. Although the SDLC typically starts with requirements
analysis and system design before moving on to implementation and deployment, our approach deviates
from this order, as the first two assignments include environment setup and coding. This was a deliberate
trade-of to ensure that each student had suficient technical skills before moving on to team assignments.
The aim of this decision was to address the gaps in students’ knowledge early and reduce the chance
of team members not contributing due to lack of skills, which is a common problem, as individual
diferences in student teams are greater than in professional teams [
Initial group assignments focused on project planning and documentation, allowing teams to define
their vision, scope, and goals. Requirements analysis followed later during the Scrum and Kanban
simulations, where TAs took on the role of clients as suggested by [
In addition to observations made by TAs during the course, we conducted an anonymous post-course survey among students (N = 22). The survey aimed to better understand students’ perceptions of the course structure, team collaboration, and technical content. It consisted of a short set of Likert-scale items and open-ended questions. Students rated their satisfaction with diferent aspects of the course (e.g., the practical labs, group collaboration, and communication) on a 5-point agreement scale ranging from “Strongly disagree” to “Strongly agree.” In addition, open-text prompts asked them to describe what they liked most, which tasks they found dificult, and how the course could be improved. This feedback complements our qualitative findings and provides additional insights into what worked well and where improvements are needed.
The mix of individual and collaborative assignments proved to be a success, as very few team issues were reported. When asked, almost all students rated communication and work within their team as excellent or great and were happy with the amount of group work. In the survey, 8 out of 22 students (36%) selected “Strongly agree” and 14 (64%) selected “Agree” when asked whether they were satisfied with the practical part of the course. This means that all respondents expressed a positive evaluation, indicating a high overall level of satisfaction with the lab assignments (as shown in Figure 2). s ten20 d u t s f o re10 b m u N 0 5
0 Agree
Strongly agree
Allowing students to choose their teammates appears to have contributed positively to team dynamics and motivation.
The gradual progression from individual to group work helped students improve their technical skills before transitioning to collaborative development. This structure appeared to reduce common problems such as uneven contributions or technical dependency on stronger team members. Many students reported feeling better prepared for team projects due to the initial individual assignments.
Scrum and Kanban simulations were most frequently cited as the most valuable and enjoyable parts of the course, with 9 (41%) students naming them as their favorite assignments in free-text responses. They appreciated the structure they provide for task management and development. The students also felt that incremental assignment provided a better learning experience compared to isolated assignments, as they were able to gradually see their project improve.
The use of GitHub instead of traditional submission was another highlight. Students preferred assignments where no submission was required as everything was uploaded on GitHub. From the instructors’ perspective, GitHub provided greater transparency into each team member’s contributions, enabling fairer assessment and earlier detection of collaboration issues.
Overall, the course succeeded in simulating many of the practices and pressures of real-world development — from coordinating as a team and responding to changing requirements to managing technical complexity over time. While the simulation was not fully comprehensive, students were exposed to multiple interconnected stages of the SDLC, and many recognized the value of working within such a structure.
While the course was well received, several recurring challenges were observed. They ranged from technical dificulties to team communication issues and workload management. These issues were also found in survey responses, where students most commonly mentioned limited project topic choices and tight deadlines. Many of these challenges are typical in collaborative student projects, but they still warrant targeted improvements in future course iterations.
Team communication proved problematic in certain groups, particularly when members were unavailable or using diferent messaging platforms. Some students began working late, making coordination harder. Git also posed issues early on, with students accidentally overwriting files or struggling with repository setup — especially those unfamiliar with version control systems.
Students also reported feeling rushed, particularly during individual assignments with tight deadlines. Additionally, the limited selection of predefined project topics left some students disengaged. On the instructor side, tracking deadlines and contributions via GitHub proved more labor-intensive than expected, as students tried to sneak in commits after the deadline, which meant that commits for each repository had to be manually reviewed.
The CI/CD assignment, introduced late in the course, was seen as too dificult and disconnected from the rest of the workflow. Meanwhile, documentation was often treated as an afterthought, and peer evaluation lacked honesty due to fear of conflict. To address these issues, we have planned several adjustments, outlined in Table 2.
We found that students engaged better when assignments formed a continuous line of work rather than
isolated tasks. For instructors, this suggests that the order and coupling of tasks matters as much as
the tasks themselves: short, linked iterations help students see progress and makes it easier for them
to follow the course than when switching between unconnected assignments. This is consistent with
reports that agile education benefits from short cycles and steady pace and that course structure needs
to be aligned with iterative work [
Using GitHub made contributions and coordination clearer, and students felt this made teamwork
fairer. At the same time, many struggled with the tool at first because the learning curve was higher
than expected. For teachers, this shows two needs: give students an early introduction to collaboration
tools, and use project data together with structured peer feedback to see how work is shared and to
step in when needed. Earlier studies also show that GitHub can improve engagement and collaboration
when used carefully [
Students valued the agile simulations, but too much freedom at the start left some unsure about the
process and what was expected. Teachers can make this easier by giving a bit of structure, such as
examples of sprint planning, short checklists for roles and communication, and by bringing practices
like CI/CD and documentation into the project earlier. This is in line with results from game-based
Scrum simulations, which show that carefully designed structure helps students focus on core agile
practices without being overwhelmed [15]. Previous studies also point out that clear communication
and visible processes are important in project courses [
A summary of key findings is listed below: • Students prefer using GitHub for submissions but need training early on to master the platform. • The team communication plan (communication platform, availability, check in time) should be defined and agreed upon at the start of group work. • Students prefer incremental work on their project to isolated assignments. • Reviewing contributions on GitHub is simple, but time-consuming if not automated. • Students value agile development but need guidance and specific instructions to help them structure development as they can get overwhelmed by too much autonomy. • Peer evaluation should be done anonymously and in a very structured manner to get honest feedback. • Students tend to create very superficial documentation if they are not forced to use it, for example during peer handovers or team rotations. • CI/CD should be introduced early and used throughout the course for the students to see the value in using it. • Predefined topics can limit creativity and reduce engagement. • Individual assignments are a great way to improve the student’s technical skills before moving on to group work
Overall, the course successfully simulated many stages of the software development lifecycle and provided students with valuable experience in both technical and collaborative aspects of software development. The course structure—combining individual tasks with group projects—helped students gain essential skills for working in real-world development teams. Survey results and TA observations indicate that students especially appreciated the agile simulations and the use of GitHub, both of which made the workflow feel more realistic. At the same time, recurring dificulties with Git, tight deadlines, and the limited set of project topics show that even small design choices can strongly shape student motivation and learning. Documentation and peer evaluation also proved to be weaker points, often treated superficially unless they were directly tied to assessment.
These findings suggest that while the general approach of simulating the SDLC is efective, the way in which assignments are sequenced and connected plays an important role. Individual assignments early in the semester helped students build confidence and reduced dependency on stronger peers, while group tasks encouraged collaboration and communication. Agile methods were seen as valuable, but students also needed clear guidance to avoid becoming overwhelmed. The CI/CD assignment gave students useful exposure to modern workflows, but its placement at the very end meant that its value was not fully recognized.
By addressing these issues, future iterations of the course can provide an even more efective and engaging learning experience, better preparing students for the complexities of professional software development. In future work, we aim to explore how automated analytics of Git activity can support fairer and more eficient assessment of individual contributions in team-based projects. We would also like to examine how integrating CI/CD practices earlier and more consistently throughout the course afects students’ understanding of modern development workflows. These findings are based on the ifrst iteration of the redesigned course. In future iterations, we aim to collect and analyze data across multiple generations to strengthen the generalizability and empirical validity of the observed outcomes.
During the preparation of this work, the authors used Grammarly for grammar, readability and spelling check. After using this tool, the authors reviewed and edited the content as needed and take full responsibility for the publication’s content.
The authors acknowledge the financial support from the Slovenian Research and Innovation Agency (Research Core Funding No. P2-0057).