I'm Building This Until It Becomes the IPMAT App I Actually Want

A few versions ago, this project had 32 questions.

No accounts.

No cloud.

No proper vocabulary system.

No offline synchronization.

No grand roadmap.

It existed because I had a vocabulary problem and wanted a better way to practise for IPMAT.

Now I can open something I built, solve verbal questions, review mistakes, learn words, maintain a streak, earn XP, save questions and continue working even if the internet disappears.

That is already much more than the first version was supposed to become.

But I don't think it is finished.

Actually, I think this is the point where the interesting part starts.

Because I no longer need to prove that I can build an IPMAT practice app.

I have one.

The question now is:

What would make this the app I genuinely want to use for the rest of my preparation?

Six questions made sense until they didn't

The original practice session contained six questions.

That was intentional.

Six is small enough that starting doesn't feel intimidating.

One session can take only a few minutes.

And because six questions originally counted toward the daily goal, the entire system fit together nicely.

But eventually I noticed something obvious.

Why should I always want exactly six questions?

Some days I might have two minutes.

Give me three.

Sometimes I might be sitting down for a proper practice session.

Give me fifteen.

Maybe I want twenty.

Maybe I want to choose something completely different.

The original fixed session size was useful because it reduced decisions while the app was tiny.

Now it has started becoming a limitation.

So the direction I prefer is simple.

Keep 6 as the default.

But let the student choose.

Something like:

Custom

The app can still recommend a sensible amount without pretending every study session should look identical.

But exam mode should not care what I prefer

There is an important exception.

An actual exam simulation should not adapt itself to my mood.

If an exam gives a fixed number of questions and a fixed amount of time, the app should reproduce that structure.

That distinction started helping me think about practice modes more clearly.

Normal learning and exam simulation serve completely different purposes.

Trying to force both into the same experience would make both worse.

The timer question became surprisingly complicated

Then I started wondering whether practice questions should have timers.

At first, timing everything sounds useful.

IPMAT is a timed exam.

So surely the app should train speed.

But imagine learning a difficult new word while a countdown is yelling at you.

That isn't really testing exam speed.

It is just making vocabulary annoying.

So I don't think there should be one timer rule for the entire product.

Instead, I like the idea of separating the experience into different modes.

Learn

This is where the goal is understanding.

No pressure.

No countdown sitting beside every word.

You can read.

Think.

Review an explanation.

Actually learn something.

Vocabulary learning belongs here.

If the purpose of the session is to acquire knowledge, I don't want the interface punishing someone for taking the time required to understand it.

Paced

Sometimes I do want time pressure.

But I would rather time the session than turn every question into a miniature emergency.

A paced mode could give me a chosen number of questions and a target amount of time.

The timer tells me how the session is progressing.

It creates pressure without necessarily auto-submitting a question the second some arbitrary limit expires.

That seems much closer to how I actually want to train speed.

Exam

Then there is the strict version.

Fixed structure.

Fixed timing.

No customising the experience because I suddenly feel like doing fewer questions.

If I want to simulate exam conditions, the app should behave like an exam.

That means the product doesn't need to choose between being relaxed and being timed.

It can understand why I opened it.

The app can still measure time quietly

Not showing a timer does not mean time is useless.

The system can still record how long I take.

That information could become extremely valuable later.

Maybe I am accurate in vocabulary questions but unusually slow.

Maybe I rush grammar questions and make avoidable mistakes.

Maybe one category consistently consumes twice as much time as another.

I don't necessarily need those numbers flashing in my face while learning.

But the system can understand them.

That leads into the part of this project I am most interested in building next.

I don't want random practice forever

Right now, the app knows useful things about me.

What I answered.

What I got wrong.

What I saved.

What words I reviewed.

How active I have been.

That is enough to build progress tracking.

But eventually I want it to make better decisions.

Suppose I repeatedly struggle with a particular grammar concept.

The app should notice.

Suppose I keep getting a word wrong even after reviewing it.

That word should probably come back.

Suppose I am excellent at one topic.

Maybe I don't need the system throwing easy questions from that category at me constantly.

Suppose I have not seen a particular important area in a while.

Bring it back.

At that point, practice stops being:

Pick six random questions.

It becomes:

Pick the questions that are most useful for me right now.

That is the adaptive layer I eventually want.

Revision should become smarter too

The same applies to vocabulary.

Right now, having a dedicated vocabulary system is already much better than where the project started.

But a list of words still isn't enough.

Some words become easy after one exposure.

Some disappear from my brain five minutes later.

Those should not be treated identically.

Eventually, review should care about things like:

How recently I saw a word.

Whether I remembered it.

How many times I have failed it.

Whether I recognise it only directly or can handle it inside a question.

How strong my recall seems to be.

The goal isn't to make some ridiculously complicated algorithm just so I can say the app has AI.

The goal is simpler.

Stop wasting my study time on things I already know, and stop letting weak things disappear.

Content becomes harder as the app gets smarter

There is another problem waiting for me.

The software can become intelligent, but it still needs good material to serve.

The original question bank had 32 questions.

Then it grew to 64.

The vocabulary system reached 154 cards.

Those numbers are enough for development.

They are nowhere near enough for the product I eventually imagine.

But I don't want to solve that by generating ten thousand random questions and calling the database complete.

The research principle from the beginning still applies.

Relevance over volume.

Every question should have a reason to exist.

Every explanation should actually explain.

Difficulty should mean something.

Topics should be traceable.

And if AI helps create content, that does not remove the responsibility to verify it.

A bad question delivered by a sophisticated adaptive system is still a bad question.

The web app is probably only the beginning

I started with the web because it was the fastest way to get the idea into my hands.

That was absolutely the right decision.

I could build one responsive product and use it on both my computer and my phone.

But if I keep using this seriously, I want the experience to expand.

The long-term target is currently:

Web

Android

Windows

Not because every project needs five different apps.

Because those are the places where I actually study.

The important part is that they should not become three unrelated products.

One account.

One learning history.

One vocabulary state.

One streak.

One source of progress.

Start a session somewhere.

Continue somewhere else.

The local-first work becomes especially important once that happens.

iOS can wait

I could add iOS to the roadmap because it makes the platform list look complete.

But that would be exactly the kind of scope inflation I tried to avoid at the beginning.

I don't currently need four platforms to prove anything.

Web, Android and Windows already create enough engineering work.

If the product eventually has a reason to exist on iOS, it can go there.

There is no prize for supporting every operating system before anyone needs it.

And yes, I started wondering whether other students could use it

This happened naturally.

At the beginning, I was building for exactly one student.

Me.

That was useful because I never had to invent a fake persona.

I knew the problem because I was living it.

But once the product started becoming more complete, another question appeared.

Would other IPMAT students want this too?

Maybe.

Could it eventually be useful for coaching institutes?

Possibly.

A tool specifically designed around IPMAT and IIM UG verbal preparation is obviously more interesting commercially than something that only exists on my localhost.

But I don't want to rewrite the origin story.

I did not begin this because I found a market.

I began because my vocabulary backlog was annoying me.

If other people eventually have the same problem, that is something I can test later.

The personal utility comes first.

That changes how I think about releasing it

If I eventually put this in front of other students, the standard becomes much higher.

A bug on my private build annoys me.

A bug that loses someone else's study progress breaks their trust.

A confusing explanation can teach something incorrectly.

A broken streak can demotivate somebody.

Bad syncing can make the app feel unreliable.

Once another person depends on the product, all the boring details become much more serious.

That is partly why I am happy to keep building it privately for now.

I am getting to be my own annoying user before somebody else has to be.

I still don't consider myself a programmer

That has been one of the strangest parts of this entire project.

If someone had shown me this app before I started building things and said:

"You'll make something like this for yourself."

I probably would have assumed I needed years of programming experience first.

I didn't.

What I needed was enough understanding to keep turning vague problems into specific ones.

The sync animation looks frozen.

The session size is too rigid.

This word needs to return later.

This state needs to survive offline.

This screen doesn't communicate what the system is doing.

Those are product problems first.

AI can help me translate many of those decisions into code.

But it cannot decide what I actually want the product to become.

That part is still mine.

This is no longer the tiny app I planned

The funny thing is that I explicitly tried to keep this project small.

I told myself I was not building another giant system.

I needed something for vocabulary.

Then it needed questions.

Then review.

Then progress.

Then XP.

Then streaks.

Then a proper vocabulary system.

Then offline support.

Then cloud sync.

Now I'm talking about adaptive practice, different learning modes and three platforms.

So I have clearly done an excellent job keeping it small.

But there is one difference compared with blindly adding features.

Almost every major addition came from actually using the previous version.

The product expanded because I found another problem.

That is the kind of scope growth I can live with.

The goal is still surprisingly simple

For all the architecture, modes, platforms and future ideas, the thing I want has barely changed.

I want to be able to open the app while preparing for IPMAT and trust that the next few minutes will be useful.

Give me something worth practising.

Remember what I struggle with.

Bring it back when I need it.

Let me learn without unnecessary pressure.

Let me train under pressure when I choose to.

Don't lose my progress.

Don't waste my time.

And eventually, understand my preparation well enough to help me decide what I should work on next.

If I can build that, then it doesn't really matter that the project started because I had too many vocabulary words sitting in my backlog.

Maybe that was exactly the right reason to build it.

Because instead of trying to imagine what an IPMAT student might need,

I already had one sitting in front of the screen.