Where the IPMAT Ecosystem Actually Stands Now

A few articles ago, I wrote a checkpoint.

The project had started with 32 questions.

By then, Verbal had become a serious private-alpha learning product.

That checkpoint already felt absurdly far from the beginning.

Now it feels old.

Since then:

Quant became real.

The analytics got much deeper.

The interface got rebuilt.

The behavioural design changed.

EBO's surviving idea found a better architecture.

Intelligence became a separate application.

The three products started sharing a common evidence model.

Android stopped being a future bullet point and became a real engineering problem.

The project is now big enough that screenshots can become misleading.

So I wanted another checkpoint.

Not:

Look how much exists.

More like:

What actually exists, what is trustworthy, and what still needs work?

Verbal is still the most mature learning product

Verbal has the longest history.

That matters.

It has gone through the most iterations.

The core learning architecture is substantial.

Vocabulary is not a flashcard list.

There are multiple learning formats.

Retention-aware scheduling.

Lapses.

Recently forgotten items.

Confusables.

Roots.

Families.

Expressions.

Typed recall.

Daily adaptive work.

Question practice has its own loop.

Review exists.

Exam behaviour exists.

Accounts and sync exist.

There is internal content tooling.

There is personal intelligence.

This remains the product that taught me most of the architecture the rest of the ecosystem now uses.

Verbal is also still unfinished

Content depth remains a major issue.

Reading needs much more breadth.

Grammar and paragraph formats need stronger transfer coverage.

The diagnostic needs to be honest about what it actually measures.

Some native/web parity still needs work.

Session and mock recovery still need hardening.

Offline, account switching and sync failure cases need real device testing.

AI-assisted sentence evaluation needs stronger quality evaluation before it deserves too much trust.

The existence of many systems does not erase those weaknesses.

Quant grew much faster

Quant benefited from every mistake Verbal already made.

So its architecture became ambitious very quickly.

Syllabus registry.

MCQ.

Short Answer.

Practice.

Review.

Formula work.

Drills.

Calculation.

DI.

Tests.

Mock analysis.

Advanced evidence.

Mastery.

Readiness.

Achievements.

Notifications.

Recommendations.

A much richer analytics model.

A stronger visual identity.

A healthier behavioural layer.

That is a lot.

Quant's biggest weakness is not architecture

It is content and production proof.

The architecture can represent much more than the current reviewed corpus can actually support.

Several domains still need real question coverage.

PYQ architecture exists without pretending random internet material is verified.

Test architecture exists without pretending every exam configuration is ready.

DI architecture exists before enough strong DI sets exist.

Readiness logic exists while population-scale calibration does not.

That distinction is healthy.

It also means Quant is not launch-ready simply because the screens look complete.

The Quant UI is much closer to the product in my head

This changed dramatically.

Home feels more intentional.

Practice is easier to enter.

Focus Mode is much better.

Review looks like repair.

Analytics has real visual evidence.

Achievements have a proper place.

Motion is restrained.

Responsive behaviour is stronger.

The product finally feels less like a dashboard for engineers and more like something a learner could actually enjoy using.

But the audit also found the next visual problem:

There is now too much useful stuff.

Home can become crowded.

Analytics can become long.

Mobile navigation can become overloaded.

So the next design phase is not:

Add more visual richness.

It is:

Edit.

That is probably progress.

Intelligence is the newest major product

This is the biggest architectural shift since the previous checkpoint.

Intelligence now has its own surfaces for:

Home.

Combined analysis.

Verbal analysis.

Quant analysis.

Skills.

Mocks.

Retention.

Planning.

Insights.

Settings.

Its learner model goes much deeper than a normal progress dashboard.

It can consider recency, difficulty, timing, retention, confidence, contradictions, evidence coverage, subject-specific patterns, mock behaviour, cross-subject allocation and intervention outcomes.

That sounds extremely powerful.

The important word is:

can.

Intelligence is not fully validated by real longitudinal usage yet

The model exists.

The shared platform exists.

Prototype data can run through the real pipeline.

The application can derive recommendations and learner-state snapshots.

That is not the same as saying:

This model has already proven itself across real learners over months.

It has not.

The subject apps still need their final canonical event integration.

Real evidence needs to accumulate.

Recommendations need outcome testing.

Thresholds need tuning.

The model needs opportunities to be wrong.

Then corrected.

That is the work that will make Intelligence genuinely good.

The shared platform is probably the least visible important thing

Verbal, Quant and Intelligence now have a path toward one coherent learner memory.

Stable events.

One identity.

Shared skills.

Attempts.

Sessions.

Reviews.

Mocks.

Recommendations.

Interventions.

Versioned state.

Idempotent retries.

Offline queues.

Server-authoritative derived intelligence.

This is not exciting to show in a screenshot.

It is what makes the screenshots capable of becoming one product instead of three disconnected demos.

Integration is the current wall

Architecture diagrams are easy compared with integration.

The actual Verbal solve flow has to emit the correct events.

The actual Quant solve flow has to emit the correct events.

Reviews need to agree.

Mocks need to agree.

Stable IDs need to remain stable.

Deep links need to return to the right repair surface.

Account switching needs to remain safe.

Retries must not inflate history.

This is where the ecosystem becomes real or falls apart.

The shared schema alone cannot do that.

Android is no longer hypothetical

This is another huge change.

There is real Android work.

A real installed app.

Native experimentation.

Haptics.

Mobile navigation.

Safe-area work.

Lifecycle problems.

Recovery bugs.

Build-pipeline confusion.

Production-signing work.

The first package proved something important:

A web app running on Android is not automatically a mobile product.

That pushed the project toward a more genuinely native direction.

Native is also one of the messiest parts right now

The repository has history.

An older Capacitor route.

A newer React Native/Expo route.

Different scripts.

Different assumptions.

The release path needs simplification.

The app still needs stronger persistence and recovery parity.

Permissions need tightening.

Accessibility needs deliberate testing.

The native build exists.

The native product is still being earned.

Security became less theoretical

As the system gained accounts, synced progress, shared evidence and more private data, security stopped being a checklist at the end.

RLS.

Ownership.

Cross-account isolation.

Minimal grants.

Server-only authority.

Secret scanning.

Account deletion.

Immutable evidence.

Release archives.

Those things became part of product correctness.

A learning system that understands the learner deeply has more responsibility than a static question bank.

That will only increase.

The project is now far beyond one app

Calling the whole thing "the Verbal app" is obviously wrong now.

There are distinct subject products.

There is cross-subject intelligence.

There is shared infrastructure.

There is native work.

There are internal content systems.

There are test engines.

There are evidence models.

The umbrella has become:

IPMAT.

That is broad enough to describe what actually exists without forcing everything into one interface.

The interesting part is what stayed consistent

Even as the architecture grew, a few principles kept surviving.

Seeing is not knowing.

A correct answer is evidence, not complete mastery.

A number should not become a conclusion without context.

A recommendation should have a reason.

A weak signal should remain weak.

The app should be allowed to say it does not know.

Mistakes should create repair.

Studying should be easier to begin and return to.

The system should not become another thing the learner has to manage.

Those ideas now connect Verbal, Quant and Intelligence more than any shared colour palette does.

The biggest risk is still pretending

Pretending content is deeper than it is.

Pretending a mock is official when the evidence is weak.

Pretending analytics are calibrated before there is enough data.

Pretending Android is production-ready because an APK installs.

Pretending a recommendation is intelligent because the sentence sounds good.

Pretending three apps are integrated because they share a backend project.

The ecosystem is now large enough that pretending would be easy.

That makes restraint more important.

What is actually strong today

The learning architecture.

The subject separation.

The evidence philosophy.

The Quant product design.

The shared learner-model direction.

The internal reliability thinking.

The willingness to leave states empty rather than fill them with fake certainty.

Those are real strengths.

What still needs the most work

Content.

Integration.

Reliability.

Native parity.

Real longitudinal evidence.

Independent review.

Security verification against the live backend.

Assessment recovery.

Offline edge cases.

Actual learner testing.

These are not minor finishing details.

They are the difference between an impressive private build and a dependable product.

The screenshots are ahead of the proof in some places

This is probably the most accurate sentence in the article.

The products can look very finished.

That is dangerous.

A polished interface can hide:

A tiny content bank.

An untested recovery path.

A missing integration.

A weak model.

A stale migration.

A native build using debug assumptions.

The next stage of the project is increasingly about making the proof catch up to the appearance.

I like that stage less than designing new features.

It is probably more important.

I no longer need another giant feature list

This is another change.

Earlier, progress meant adding capability.

Now the ecosystem has enough capability.

The next wins are more boring.

From 32 questions to a learner model

That progression still makes me laugh.

The original problem was small.

I wanted better vocabulary practice.

Then the project kept exposing larger problems.

Learning.

Retention.

Practice.

Exams.

Quant.

Evidence.

Intelligence.

Shared memory.

Native.

Every layer came from trying to make the previous layer more honest.

That is probably the story of the project now.

Not feature expansion for its own sake.

A sequence of:

This works, but what is it missing?

Where the ecosystem actually stands

Verbal is a deep but unfinished learning product.

Quant is a broad and increasingly polished product whose architecture is ahead of its content.

Intelligence is a real learner-model application whose value now depends on real integration and longitudinal evidence.

The shared platform exists as the memory connecting them.

Android has moved from future roadmap to active engineering.

The whole system is still private enough that I can break things without hurting real learners.

That is useful.

I should use that advantage.

The next version does not need to look dramatically more impressive.

It needs to be harder to break.

Harder to misinterpret.

Harder to lose progress in.

Harder to fool with weak evidence.

And easier to trust.

That is where the IPMAT ecosystem actually stands now.