My first authentication system with Python (login & registration)

One of the first complete projects I developed during my studies was a user management system with registration and login, built in Python.

Even though it is an introductory-level project, it was key to understanding fundamental concepts such as authentication, data modeling, separation of concerns, and teamwork.

💻 Repository: https://github.com/Grupo-22-ISPC/Evidencia-3-Prog-y-BD

📌 Project context #

This project was developed as part of an integrative assignment in the Programming I course.

The main goal was to build a system capable of:

• Registering users
• Handling login authentication
• Managing roles (admin / user)
• Managing accounts (list, update, delete)

In addition to the Python application, a relational database design in MySQL was also created, although not yet integrated into the system.

🏗️ Approach and architecture #

One of the most important decisions was to clearly separate responsibilities within the system. For that, three main classes were defined:

• Usuario: represents user data
• GestorUsuarios: handles business logic (registration, login, validations, etc.)
• Sistema: manages user interaction (menus and application flow)

This approach allowed for a clean and organized structure, even as a console-based application.

The system currently works in memory, simulating database behavior using internal data structures.

🗄️ Database design #

Alongside the Python application, a normalized relational database (3NF) was designed with two main entities:

• usuarios
• roles

The relationship between them is one-to-many, where each user has one role, but a role can belong to multiple users.

This design helped to:

• Avoid data redundancy
• Separate responsibilities
• Prepare the system for future database integration

🔑 Main features #

The system implements the core operations of an authentication system:

• User registration
• Login with credential validation
• Role assignment and modification
• User deletion
• Role-based data access

It also includes basic validations such as:

• Checking for existing users
• Password rules

🧩 Teamwork and methodology #

The project was developed in a team using an agile approach:

• Kanban board
• Issues and task tracking
• Documentation through GitHub Wiki
• Role-based task distribution

Although responsibilities were defined, in practice I contributed across multiple areas, including:

• Implementing and improving CRUD operations
• Enhancing console menu flows
• Fixing bugs in the system logic

This gave me my first real experience working in a collaborative development environment.

⚠️ Limitations #

As part of the academic scope, the project has some limitations:

• No real data persistence (data is lost when the app closes)
• No integration between the application and the database
• Passwords are not encrypted

These limitations are part of the learning process and open the door for future improvements.

🚀 What I learned #

This project helped me understand:

• How to structure an application beyond a single file
• Separation between business logic and presentation
• Data modeling and normalization
• Basic authentication logic
• Team collaboration using real tools

💡 What I would improve today #

If I were to rebuild this project, I would:

• Integrate the application with MySQL
• Implement password hashing
• Apply a more scalable architecture (e.g., MVC)
• Add automated tests
• Build an API instead of a console application

🧠 Conclusion #

Beyond its simplicity, this project represents an important starting point in my journey as a developer.

It not only allowed me to apply technical concepts, but also to understand how software is built in teams, how decisions are made, and how a system evolves from an initial idea into a functional solution.