EduPulse — Real-Time Adaptive Learning with AI on Data in Motion

About the Project

EduPulse is a real-time adaptive learning platform that monitors live learner behavior during an active session and responds immediately with personalized support.

Most learning platforms detect disengagement after it happens—after quizzes, after sessions, or after grades are finalized. By that point, the opportunity to help has already passed.

EduPulse is built to intervene during the learning session, when support is most effective.

What EduPulse Does

EduPulse enables in-the-moment learning adaptation through:

Live engagement scoring as learners interact
Real-time difficulty and content adjustments
Contextual hints for students
Actionable coaching tips for instructors

Why Streaming + AI (Not Batch Analytics)

Engagement shifts in seconds, and the window to help is narrow
Batch analytics can explain what happened, but cannot change what is happening
Streaming turns every learner interaction into a live signal that can trigger immediate action

EduPulse is designed around AI on data in motion, not retrospective analysis.

Inspiration

We were motivated by a recurring pattern in education: students often don’t fail because the content is too hard—they fail because they get stuck, lose momentum, and disengage before support arrives.

The engagement gap we focused on is subtle but critical. It appears when:

retries spike
pacing slows or accelerates unexpectedly
attention drops
frustration builds without visible signals

Traditional learning platforms rely on periodic checkpoints. EduPulse challenges that assumption.

What if a learning platform could react as fast as a learner’s attention changes?

Real-time intervention shifts education from post-mortem feedback to in-the-moment guidance.

What We Learned

1. Kafka and Streaming-First Design

Thinking in streams forced us to treat every interaction as part of an ongoing narrative, not a standalone request
We learned to preserve ordering where it matters (session-level) while still scaling across many concurrent learners

2. Schema Registry and Avro Governance

Event contracts mattered more than expected, especially with independent producers and consumers
Avro required explicit thinking about evolution:
- defaults
- nullable fields
- backward compatibility
Schema governance proved essential for stability in real-time systems

3. Real-Time AI vs Batch AI

“Adding AI to the pipeline” is easy to say but hard to operationalize
We learned that:
- inference latency becomes a product feature
- timeouts and fallbacks must be designed upfront
- streaming AI is about decisions under time pressure, not perfect predictions

4. Event-Driven Architecture Realities

Kafka simplified service integration but raised the bar for correctness:

message contracts
replay safety
dead-letter handling

Failure had to be treated as a default state, not an exception.

How We Built It

At a high level, EduPulse is a continuous loop of signals, decisions, and feedback.

End-to-End Flow

Learner interactions and quiz attempts generate Kafka events
Engagement scoring converts events into a live state estimate
A policy or bandit component selects the next action
Generative AI produces targeted student hints and instructor guidance
A real-time gateway streams updates directly into the UI

Kafka Event Flow

Event Producers

The platform produces events for:

Session behavior (navigation, dwell time, focus/blur, pacing signals)
Quiz attempts (answers, retries, correctness, response latency)

Event Consumers and Decisions

Downstream services consume these signals and publish:

engagement score updates
adaptation actions (difficulty or content changes)
instructor coaching tips

Engagement Scoring

Engagement is modeled as a continuously updated score, not a session summary
The score is computed over short time windows to remain actionable

Conceptually:

[ E_t = \sigma(\alpha \cdot \text{pacing}_t - \beta \cdot \text{retryRate}_t - \gamma \cdot \text{idle}_t + \delta \cdot \text{attention}_t) ]

The exact formula is less important than the requirement that it updates fast enough to influence live decisions.

Vertex AI in the Decision Loop

Vertex AI is used for real-time inference when decisions must be made quickly:

engagement classification (when applicable)
contextual bandit or policy selection for difficulty and next-best activity

Each decision is framed as: choose an action given the current live context.

Gemini for Student Hints and Instructor Tips

Gemini generates:

student-facing hints and explanations based on mistakes and skill context
instructor coaching tips that translate engagement signals into actions

Outputs are constrained to be:

short enough for real-time delivery
grounded in the current session state
safe to fall back to templates if inference is slow or unavailable

Spring Boot and Next.js Integration

Spring Boot services handle:
- event production and consumption
- engagement scoring
- AI inference calls
Next.js provides:
- the student learning experience
- the instructor dashboard
- live UI updates through a real-time delivery channel

The UI visibly adapts mid-session, reinforcing the real-time nature of the platform.

Challenges We Faced

Latency and Real-Time Expectations

Producing events was easy; responding fast enough was not
AI inference introduced unpredictable delays
We designed explicitly for:
- timeouts
- fallback behaviors
- caching for repeated patterns

Schema Evolution Under Pressure

Hackathon velocity caused frequent schema changes
Backward compatibility required discipline:
- safe field additions with defaults
- avoiding breaking type changes
- consumer resilience to unknown fields

Streaming Complexity

Debugging systems in motion required new thinking around:

consumer lag
ordering guarantees by key
deduplication and replay scenarios

AI Output Quality and Reliability

Prompt quality mattered, but consistency mattered more
We focused on:
- avoiding over-explanation
- ensuring instructor tips were actionable
Mitigations included:
- structured prompting
- deterministic fallback templates