I had to take a break from this project due to exams, and coming back to it made me realize how much consistency actually matters in programming.
Even small things like running migrations or adding components to settings slipped out of my mind, even though I had done them before. I ended up spending almost an entire day just reading my own code to understand what was going on. That made it very clear that learning is not just about picking up new stacks or technologies, but about staying consistent enough to build and retain understanding from top to bottom.
Picking Up Where I Left Off
Before the exams, I had already set up a base user class (got stuck for a while on the user manager), integrated Clerk for authentication, and added it globally in the settings. After coming back, I started working on the actual models for the main components of the project.
I decided to focus first on the core components like projects and tasks. Before writing the models, I thought through a few rules that these components should follow.
Project and Task Rules
Below is a rough diagram I made while thinking through how projects and tasks should behave and relate to each other:
Having these rules written down helped a lot while designing the models and keeping things consistent.
Models, Services, and APIs
The models themselves were fairly intuitive since I have worked with SQL before. The only part I got a bit stuck on was Meta, but that also became clear after reading through the docs.
After defining the models, I created service classes for creating, updating, deleting and fetching projects so they could be reused later when building APIs. Once that was done, I moved on to building the APIs with URLs and tested everything using Postman. Since I am already familiar with it, testing was quick, even though I ran into pretty much every possible error along the way. After fixing those I added tests for both the services and APIs so I can now just run the tests to check whether things behave as expected.
Problems I Faced
While working on this part of the project, I ran into a few problems, most of which were due to my own stupidity:
I overcomplicated things at the beginning. Focusing only on core functionality would have been a better approach, especially since the main goal of this project was learning.
Instead of using an online PostgreSQL server during development, I ran the project directly from Docker. This meant rebuilding containers and using the container terminal every time, which turned out to be a bad decision.
I did not have a frontend initially. This made testing authentication painful because getting auth tokens from Clerk required impersonating a user and using the console every time. Later on, I found out about session templates, which would have made this much easier.
Thoughts on Using AI While Learning
Earlier, I was not really into using AI while learning a new stack. Working on this project changed my view a bit. I don't think copying and pasting code from AI helps much, but using it as a tool to understand things does.
What helped me more was reading the generated code, asking what each part is doing and why it is written that way, then trying to fix issues on my own. Asking for hints instead of full solutions felt more useful. I think if you are writing the code, you should still understand what is happening and be able to notice when something feels off, even if the code comes from AI.
What Next (Maybe)
I might expand this project further by adding things like Celery for background tasks or workspaces with profiles, but I am not completely sure yet. I am also thinking about starting a separate project related to chess and machine learning.
GitHub Link
If you want to check the project, here’s the GitHub link:
https://github.com/negihimanshu015/Tenguin
Top comments (0)