My Verbal App Turned Into an IPMAT Ecosystem

This project was supposed to help me learn vocabulary.

That sentence becomes more ridiculous every time I write it.

The first version had 32 questions. Then vocabulary became a real learning system. Then came review, accounts, sync, exam simulation, personal intelligence, content tooling and all the reliability work underneath it.

By Part 17, the project was already far beyond the tiny tool I had originally needed.

Then I started building Quant.

And the question changed.

It was no longer:

How good can I make my Verbal app?

It became:

What happens when two different learning products understand different parts of the same student?

That question changed the architecture of everything.

Verbal had become deep enough to deserve staying Verbal

The obvious move would have been to add Quant into the existing app.

Arithmetic beside vocabulary.

Geometry beside reading comprehension.

DI beside grammar.

One enormous IPMAT application.

I could have done it.

I did not want to.

Verbal had developed its own logic. Vocabulary needed recall, retention, confusables, roots and repeated evidence. Reading needed passage-level behaviour. Grammar needed its own evidence. Timing meant something different from Quant timing.

Trying to force Quant into the same interface would have made the product broader while making its identity weaker.

So Verbal stayed Verbal.

Quant deserved a different product

Quant has different failure modes.

A student can understand a concept and still execute it too slowly.

They can be fast and careless.

They can know a formula but fail to recognise when it applies.

They can solve a difficult question correctly and still waste too much exam time doing it.

Short Answer questions behave differently from MCQs.

Calculation deserves separate attention.

DI is not just another topic card.

So I stopped thinking:

How do I add Quant to Verbal?

and started asking:

What would a Quant product look like if I treated it with the same seriousness I eventually gave Verbal?

That became a second application.

Not a tab.

Not a recoloured copy.

This time I knew some of the traps

Verbal grew organically. That was useful, but chaotic.

Quant benefited from the mistakes.

Before building deeply, I mapped the syllabus, topics, subtopics, question types, difficulty, exam relevance, practice, review, drills, tests, analytics, evidence and persistence.

The strange advantage of making architectural mistakes once is that the next product inherits the scars.

Then the project split into three different questions

Once Quant existed beside Verbal, I noticed something.

Verbal could answer:

How am I doing in Verbal?

Quant could answer:

How am I doing in Quant?

But neither could fully answer:

How am I doing in my preparation?

Suppose Verbal is improving while Quant is stagnant.

Suppose untimed Quant is fine but timed execution is poor.

Suppose vocabulary retention is slipping while Quant review debt is growing.

What deserves attention today?

That answer does not live entirely inside either subject product.

The evidence exists in both.

The interpretation sits above them.

That was the beginning of Intelligence.

This was strangely close to EBO

EBO wanted to understand studying.

That was one of its best ideas.

It was also part of why the standalone product failed.

If I studied from a book, EBO did not know what happened. If I solved a worksheet, it did not know my accuracy. To become intelligent, it needed me to report more information or let it observe more.

The productivity app started creating productivity overhead.

Verbal and Quant have a different relationship with evidence.

If I solve a Quant question inside Quant, the system already knows the question, topic, answer, correctness, time and later repair history.

If I review vocabulary inside Verbal, the system already knows that too.

The learning activity itself creates the evidence.

No post-session questionnaire required.

Verbal knows Verbal

Verbal should understand its own subject deeply.

Vocabulary retention.

Recall.

Reading.

Grammar.

Weaknesses.

Review.

Exam execution.

That is already a hard problem.

Quant knows Quant

Quant has its own world.

Arithmetic.

Algebra.

Geometry.

DI.

Short Answer.

Calculation speed.

Formula use.

Timed execution.

Mocks.

Again: plenty to understand.

Something else needed to know the learner

That became Intelligence.

Its job is not to teach vocabulary or solve arithmetic.

Its job is to ask larger questions.

What is changing?

Where is the evidence strong?

Where is it weak?

What looks conceptual?

What looks like execution?

What is being forgotten?

What deserves attention next?

That is not another practice app.

It is a learner model.

Evidence and interpretation needed to separate

Suppose I answer a Quant question incorrectly.

That is evidence.

Now suppose the system says:

You have a conceptual weakness in percentages.

That is interpretation.

Maybe I misread the question.

Maybe I made a sign error.

Maybe I rushed.

Maybe I genuinely do not understand the concept.

The system should not confuse those things.

So the architecture began separating:

What happened

from:

What we think it might mean.

Observations can be stored.

Inferences need confidence.

They can strengthen, weaken or disappear when better evidence arrives.

The app should be allowed to change its mind.

Three interfaces started making more sense than one giant one

Verbal is where I improve Verbal.

Quant is where I improve Quant.

Intelligence is where I understand the larger preparation state.

Three different jobs.

Three different experiences.

The fact that they belong to one preparation system does not mean they need to become one enormous interface.

Separating them may be what keeps each one usable.

But they still need to remember the same person

Separate apps create another problem.

Identity.

If each product invents its own incompatible definition of an attempt, mistake or skill, combining them later becomes painful.

If the same event can be counted twice after a retry, the learner model becomes polluted.

So the ecosystem needed a shared language underneath the interfaces.

Not identical interfaces.

Shared evidence.

Attempts.

Sessions.

Reviews.

Mocks.

Skills.

Recommendations.

Interventions.

Learning state.

That became the shared platform underneath the products.

Intelligence became an actual application

At first, shared intelligence was mostly an architectural idea.

Then it got a real interface.

Home.

Combined analysis.

Verbal analysis.

Quant analysis.

Skills.

Mocks.

Retention.

Planning.

Insights.

Settings.

And suddenly the difference between analytics and intelligence became much clearer.

Analytics tells me what happened.

Intelligence should help explain why it might matter and what I should probably do with that information.

Not magically.

Not with fake certainty.

With evidence.

The ecosystem is still unfinished

The architecture exists.

The products exist.

The shared learner model exists.

That does not mean every integration is complete.

Verbal and Quant still need their real event flows wired cleanly into the shared platform.

Intelligence still needs real longitudinal use before I trust every cross-subject conclusion.

Quant has serious architecture, but not every planned PYQ, mock or large content bank exists yet.

Native work is progressing, but the mobile product is not finished.

The system is much larger.

So are the remaining problems.

But I finally understand what I'm building

For most of this series, the project kept surprising me.

Vocabulary app.

Verbal app.

Learning system.

Exam app.

Personal intelligence.

Now the responsibilities finally make sense.

Verbal helps me get better at Verbal.

Quant helps me get better at Quant.

Intelligence helps me understand the learner those two products are observing.

And the shared platform underneath them makes sure they are talking about the same person.

That is the IPMAT ecosystem.

The funny part is that I never sat down and decided:

I am going to build an ecosystem.

I wanted to remember vocabulary.

Then I wanted better practice.

Then better evidence.

Then Quant needed the same seriousness.

Then the evidence from both products became more valuable together than separately.

The architecture followed the problems.

Which is probably why I trust it more than if I had drawn the ecosystem diagram before building anything.