Where This Started
A few months back, I was getting a large amount of science homework. It wasn’t just regular assignments. It was a heavy workload on top of long online quizzes through Educake.
These quizzes were often around 100 questions long, and the expectation was to keep reattempting them until you reached 100 per cent.
To be fair, Educake works well as a learning platform in theory. It helps identify gaps in knowledge and is designed to reinforce understanding over time. I can see why it’s used in schools.
But in practice, in my environment, it often felt different. People would compare answers, search online, or reuse information from previous attempts. Over time, it shifted away from feeling like learning and started feeling more like completing a system in whatever way worked fastest.
That shift is what eventually led me to build something of my own.
The Idea Behind EduQuick (Original Intent)
The project I built was called EduQuick.
At first, it wasn’t meant to be public or even a “project” in the usual sense. It started as a personal tool, something I was building for myself.
The original idea was straightforward. I would complete an Educake quiz properly first, then use a script to collect the answers from that completed attempt. After that, I could reuse that information when reattempting similar quizzes, reducing the need to repeatedly go through the same content in full.
At that stage, the intention wasn’t to avoid learning. It was more about reducing repetition after already engaging with the material once.
It was a very narrow, personal workflow improvement rather than anything broader.
How It Became a Working Tool
When I started building it, I was still fairly new to JavaScript. Most of what I used, I learned as I went.
Because the script ran in the browser, I had to understand how client-side JavaScript actually behaves in practice. That meant working directly with the browser environment, experimenting, and figuring things out through trial and error.
Compared to my other projects, EduQuick came together extremely quickly. From the initial idea to figuring out the interface, learning the necessary JavaScript, and getting a working version running, it took around four hours.
That included everything: exploration, implementation, debugging, and testing while I was still learning how the system worked.
At the time, I didn’t think of it as extra work. It was just part of the same cycle I was already in, building things constantly and learning through them.
Exploring How the System Worked
Once the basic version was working, I became curious about how Educake functioned behind the scenes.
I started looking into how quiz submissions were handled and how answers were processed in the browser. While doing that, I identified endpoints involved in marking responses and returning correct answer data.
Around the same time, I came across another public project:
That project used similar endpoints and submitted placeholder values to retrieve correct answers from quizzes. Seeing that confirmed that I wasn’t the first person to explore that kind of system behaviour.
How EduQuick Went Further
The difference in my case was how far I decided to take the idea.
Instead of just collecting answers after completing a quiz or using it in a secondary attempt, I started exploring whether it could be extended into something that handled everything in a single run.
At that point, it felt less like a finished tool and more like a technical challenge. It was part curiosity, part experimentation, and part trying to understand what was possible within the system.
From my perspective at the time, I saw it as a technical problem to explore, a way to reduce repetitive work, and an exercise in automation.
I also didn’t initially view it through a harmful lens. Everything I was interacting with was accessible through the browser, and I was approaching it as a system to understand rather than something to interfere with in a broader sense.
What I Learned From It
Despite how the project started and where it ended up, I learned a significant amount from building it.
I learned JavaScript in a practical way, far more than I would have through theory alone. I became comfortable working with browser DevTools and understanding how front-end behaviour changes in real time.
I also gained a much clearer understanding of how web systems communicate. HTTP requests, GET and POST behaviour, and JSON structure all became more intuitive once I saw them being used in an actual system.
Beyond that, I was exposed to concepts I had only previously read about, including XSRF tokens (Cross-Site Request Forgery protection), JWTs (JSON Web Tokens), and session-based authentication. Seeing them in practice made them far easier to understand.
Even smaller implementation details, like caching behaviour and how static assets are hashed and served, became clearer through direct observation.
It was one of the first times I fully understood how many components exist behind something that, on the surface, looks simple.
Why I Put It on GitHub
After building EduQuick, I decided to publish it on my GitHub profile.
At the time, I was proud of it from a learning perspective. It was built quickly, it combined experimentation with real system behaviour, and it demonstrated how quickly I could pick up a new language and apply it.
I also documented it properly and added visuals so it felt like a complete project rather than just a script.
My mindset was that it represented a technical experiment and a stage in my learning process, and I wanted to include it as part of my development journey.
What Changed Afterwards
A while later, my school situation changed, and I was moved into a different class. As a result, I no longer had Educake assignments in the same way, and EduQuick naturally stopped being something I needed.
Around March 14th, Educake updated its system so that the endpoint I had been using no longer worked as expected.
After that, I briefly explored what had changed. I checked public demo quizzes and used browser tools to understand how the behaviour had shifted. I also found another endpoint that still worked in limited cases.
From my perspective, it seemed like parts of the system were still accessible in different forms, and I tested those changes out of curiosity.
However, after releasing an update and seeing further changes introduced, it became clear that the system was being actively adjusted in response. At that point, I chose not to continue developing it further.
When It Became a School Issue
On April 15th, I came into school and learned that there had been a discussion involving staff earlier that day.
Shortly after, I was called in for a meeting and spoken to directly. My parents were contacted afterwards.
The outcome was a warning, and I discontinued the project entirely.
Aftermath and Archiving
After the situation, I archived the EduQuick repository and stopped all development on it.
Before I even fully returned to normal classes, the situation had already spread among students and staff. Some teachers viewed it as a serious issue, while others acknowledged the technical side of the work, even if the context wasn’t appropriate.
There was also increased attention from students towards my other projects and website, which I didn’t expect at the time.
Reactions were mixed. Some classmates saw it as technically impressive, while others viewed it as the end of a particular phase.
Final Thoughts
Looking back, I understand more clearly now that intent doesn’t always matter as much as impact.
Even though the project began as a personal tool and was originally intended to reduce repetition rather than bypass learning, it still interacted with a real production system in a way it wasn’t designed for.
I am not presenting it as something to be proud of in a negative sense. It was a learning experience, and one that came with real consequences.
After everything, I stepped away from Educake entirely. Not because I think it is a bad platform, but because I don’t want to fall back into that same mindset of curiosity applied in the wrong direction.
At the same time, I still think it is a genuinely useful learning tool when used as intended.
This project ended, but the lessons from it stayed with me.