How an EdTech Platform Designed Its AI to Use 90% Less Input

An edtech company rebuilt its notifications and added student fit narratives where code makes every match and GPT-4 only writes, designed to cut model input ~90%.
~90%
Projected cut in model input
4–6 months
Implementation Time
Not disclosed
Project Cost

the challenge

At this education technology company, notifications ran on a legacy system where every product team sent messages its own way, with no central control or prioritization. Urgent messages and routine nudges reached students with equal weight, and the ones that mattered got lost. Students exploring college and career options saw generic pages with no evidence-backed explanation of why a path fit them. The company wanted to bring AI deeper into that experience, and for young people making real decisions about their futures, doing it responsibly and affordably was a hard bar to clear.

what they built

The work spans two builds. The first is a centralized notification platform. It pulls every product team's requests into one pipeline, a prioritization engine scores each message by urgency and user preference, and a scheduler delivers it to mobile or email at the right moment, so the messages that matter surface and the rest stop piling up. The second is an explainable AI personalization layer for college and career pages. For each student it generates a plain-English "Why For Me" narrative and "Fit Signals" cards, with every claim tied to a specific data point from the student's profile, drawn through Model Context Protocol. The defining decision is what the AI isn't allowed to do. Data retrieval, scoring, selection and validation run in conventional software on Azure Functions, and GPT-4 through Azure OpenAI only writes the final student-facing language. The backend pre-scores the relevant options, packs only the student responses tied to each one into a compact evidence packet, and sends a tightly controlled prompt. The model returns structured JSON that is validated against schema and writing rules before it reaches a student. Because the logic lives outside the model, the client can evaluate or swap models without rebuilding the product.
The engagement began as a rebuild of the company's notification infrastructure. Every product team had been sending messages its own way, so the first build pulled those requests into a single pipeline, added a prioritization engine that scores each message by urgency and user preference, and a scheduler that delivers it to mobile or email at the right moment. The second build added an explainable personalization layer to the college and career pages. The team set one rule early: code handles retrieval, scoring, selection, validation and caching on Azure Functions, and GPT-4 through Azure OpenAI only writes the final student-facing copy. The backend pre-scores options, compresses them into evidence packets holding only the relevant student responses, and sends a tightly controlled prompt. The model returns JSON that is validated against schema and writing rules, with retry and repair when live data is messy or incomplete. Before any production code, a batch run wrote 120 real outputs to a spreadsheet for leadership to review. Midway through, a requirement to keep student data inside the client's Azure environment shifted model selection from the cheapest external provider to the safest compliant option. First meaningful results arrived in four to six months.

best fit for

Edtech and learning platforms, companies under strict data-residency commitments, and multi-product SaaS organizations.
Ai ROLE
GPT-4 through Azure OpenAI writes the final student-facing narrative and Fit Signals cards. Everything before that, from retrieving Model Context Protocol profile data to scoring, selecting and validating options, runs in conventional code on Azure Functions, and only a compact evidence packet reaches the model.

impact

102K to 8K

Projected input tokens per request with evidence packets, from Atomic Build's design analysis.

120

Real outputs reviewed by leadership before any production code was written.

1

Notification pipeline now carries every product team's messages, with prioritization and scheduling.

implementation complexity

Expert rated Medium. Two builds (notification platform plus personalization layer), schema validation with retry and repair on messy live data, and a midstream data-residency requirement; 4 to 6 months to first results. Medium holds, arguably Medium-High.
Amit Ahluwalia

Amit Ahluwalia

Head of Product Development at Atomic Build
Atomic Build
Leads product and delivery at Atomic Build, an AI product and engineering firm that builds AI-native products, modernizes legacy systems and ships internal tools.
Get an intro
Talk to this team
industry
Education & EdTech
business organization
Product & Engineering
AI TYpe
Recommendation Systems
value type
Customer Experience

more from this expert

No items found.

frequently asked questions

How did an edtech company design its AI personalization to use 90% less model input?

The backend scores and selects the relevant college and career options in code, then packs only the student responses tied to each option into a compact evidence packet. GPT-4 gets that packet instead of the full student and career data. Atomic Build's design analysis projects this cuts model input by about 90%, from roughly 102,000 to 8,000 tokens per request.

What AI model and tools were used for the student personalization layer?

GPT-4 through Azure OpenAI writes the final narrative. Retrieval, scoring, selection and validation run in conventional code on Azure Functions, using Model Context Protocol profile data, JSON prompt templates, prompt versioning, generation event logging and an Angular internal frontend. Keeping the logic outside the model lets the client change models without rebuilding the product.

What results did the edtech company achieve?

Every product team's notifications now run through one prioritized pipeline, and students see evidence-backed explanations of why a college or career path fits them. The design analysis projects about 90% less model input per request, which lowers operating cost and constrains what the model can say. Atomic Build describes this as a projected reduction from its design analysis, and it hasn't been measured in production.

How long did the notification and personalization build take?

First meaningful results arrived in four to six months. Before production code was written, leadership reviewed 120 real outputs from a batch run to judge quality.

Who is explainable AI personalization best for?

Edtech and learning platforms, companies under strict data-residency commitments, and multi-product SaaS organizations that need control over how many product teams message the same users.

Have a similar challenge?

Ask whether this would work for you, or describe what you're trying to solve.
TELL US WHAT YOU'RE EXPLORING