I'm 18, Self-Taught, and I Built an AI Study App for Nigerian Students — Here's How

• When I sat down to build Aveliq, I had one goal: give every Nigerian student access to tools that actually help them study smarter. Not a repackaged ChatGPT wrapper. Not another generic quiz app. Something built specifically for WAEC, JAMB, NECO and Post-UTME — the exams that actually determine the trajectory of millions of Nigerian students every year.

My name is George Erubami. I go by GeoCode. I'm 18 years old, self-taught, based in Ibadan, Nigeria. I built Aveliq end to end — frontend, backend, AI integration, design, deployment, legal pages, PWA setup, everything. This is the story of how I did it and what I learned.

What Aveliq Does

Aveliq is an AI-powered study companion. Here is what it does right now:

• AI Summaries — paste any notes and get a structured study guide with key concepts, common exam errors, and revision tips tailored to your subject and exam board
• Exam Quizzes — generate WAEC and JAMB style questions from your notes, submit answers and get instant detailed feedback
• 7-Day Revision Plans — personalized study schedules built from your actual notes, time-boxed and actionable
• Vexio AI Tutor — a dedicated chat screen where students can ask anything about their subjects at any time
• YouTube Analysis — paste a YouTube link and get a full study guide from the video content
• PDF and Photo Upload — snap a textbook page or upload a PDF, OCR extracts the text, Vexio processes it
• Flashcards, Focus Timer, Streaks, Achievements — the consistency layer that keeps students coming back

Everything is powered by what I call GEOCODE Intelligence — a five-provider AI chain that I built to ensure the app is always fast and always available, even on the free tier.

The Tech Stack

Frontend: HTML, CSS, Vanilla JavaScript. No framework. No build tool. I build on Android using Termux and Acode, so keeping the toolchain simple was a deliberate choice
Backend: Node.js with Express, deployed on Render.

Database and Auth: Firebase Firestore and Firebase Authentication.

Deployment: Vercel for the frontend, Render for the backend.

AI: Five providers chained together — more on this below.

The Most Interesting Technical Decision: The AI Fallback Chain

The heart of Aveliq's backend is what I call the GEOCODE Intelligence chain. Every AI request goes through this waterfall:

Cerebras → Groq → OpenRouter → Mistral → Gemini

Here is why I built it this way.

The problem with relying on one provider

Every free-tier AI API has rate limits. Cerebras allows a certain number of requests per minute. Groq has its own limits. If you build your app on a single provider and that provider hits its limit or goes down, your entire app breaks. For a study app used by students the night before an exam, that is unacceptable.

How the chain works

javascript
async function callAI(prompt) {
const result =
await callCerebras(prompt) ||
await callGroq(prompt) ||
await callOpenRouter(prompt) ||
await callMistral(prompt) ||
await callGemini(prompt);

if (!result) throw new Error('All AI providers failed.');
return result;
}

Each provider function returns null on failure or rate limit, and the next one in the chain is tried automatically. The student never sees an error — they just get a response, slightly slower at worst.

Why Cerebras first

Cerebras is the fastest inference provider I have found. Their Llama 3.3 70B model responds in under two seconds for most requests. That is what makes Aveliq feel instant — most requests never even reach Groq.

The Rate Limiter

Because I am on free tiers across multiple providers, I also needed to protect my own backend from abuse. I built a simple sliding window rate limiter:

const rl = new Map();

function rateLimiter(req, res, next) {
  const ip  = req.headers['x-forwarded-for']?.split(',')[0] || req.ip;
  const now = Date.now();
  const win = 60 * 60 * 1000; // 1 hour
  const lim = 60;              // 60 requests per hour

  if (!rl.has(ip)) rl.set(ip, []);
  const calls = rl.get(ip).filter(t => now - t < win);
  calls.push(now);
  rl.set(ip, calls);

  if (calls.length > lim)
    return res.status(429).json({ error: 'Rate limit reached.' });
  next();
}

It is IP-based, in-memory, and cleans itself up every hour. Simple and effective for the current scale.

Building on Android

I want to talk about this because it is something most tutorials assume you do not have to deal with.

I built Aveliq entirely on Android. My tools are Termux for the terminal, Acode as my code editor, and GitHub for version control. No MacBook. No desktop. No VS Code with extensions. Just a phone.

This forced me to make certain decisions:

No build tools. No Webpack, no Vite, no bundlers. The frontend is raw HTML, CSS and JavaScript. This means every file is exactly what gets served — no compilation step, no source maps, no build errors. It is also why the app loads fast.

No local server testing. I deploy early and often. Push to GitHub, Vercel auto-deploys, test on the live URL. This made me very deliberate about what I commit because every push is a real deployment.

Termux for Node. Running node server.js locally on Termux is how I tested backend logic before pushing to Render. It works, but it taught me to write clean, readable server code because debugging on a phone screen is not fun.

The PWA Setup

Aveliq is a Progressive Web App. Here is what that means in practice:

• A manifest.json with proper 192px and 512px PNG icons (not SVG — iOS home screen requires PNG)
• A service worker that caches all static assets and serves an offline fallback page when there is no connection
• An install prompt that appears automatically on Android Chrome via the beforeinstallprompt event
• An apple-touch-icon.png at 180x180 for iOS home screen

The offline fallback is something I care about specifically for Nigerian users. Data is expensive and connections drop. If a student has already loaded Aveliq and their connection drops mid-session, they should not see a blank screen — they should see their cached content and a clear message about what happened.

What Is Coming Next

Session 3 — Past Questions Engine

This is the feature I am most excited about. The architecture is community-powered:

1. A student uploads a photo or PDF of a real WAEC, JAMB or NECO past question paper
2. OCR extracts the text
3. Vexio structures it into clean Q&A JSON
4. It saves to a shared Firestore collection
5. Every other student who searches for that paper gets it instantly — no OCR needed again

The database builds itself as users grow. The first person to upload a paper does the work once, everyone benefits forever. We also add a verification layer — if three different users upload the same paper and the questions match, it auto-verifies. No fake questions get into the pool.

Session 8 — Paystack Integration

Free tier with daily limits. Premium at ₦1,500/month for unlimited access. Exam Prep at ₦3,500 for three months. Payment gated via Paystack with a Firebase webhook to update subscription status.

What I Have Learned

Ship fast, fix in public. The old Aveliq had problems. Instead of fixing it quietly, I rebuilt it completely and documented the process. Building in public keeps you accountable and attracts people who want to see you succeed.

The AI is not the hard part. Calling an API is five lines of code. The hard part is the user experience around it — the loaders, the error states, the fallbacks, the identity layer, the rate limiting. The AI is just the engine. The product is everything else.

Build for your user's reality. My users study on 2G connections in rented rooms with shared data. Every design decision — the PWA, the offline fallback, the fast AI chain, the WhatsApp share button — came from thinking about that specific person, not an imaginary ideal user.

You do not need the right tools. You need to start. I built this on a phone. The tools are not the barrier.

Try It

Aveliq is live at studypal.com.ng

The app is at studypal.com.ng/app

I post updates on my portfolio at george-erubami.vercel.app

If you are a Nigerian student — try it. If you are a developer — tell me what you think. If you want to follow the build — I document every session.

Built by George Erubami (GeoCode) — 18-year-old self-taught developer from Ibadan, Nigeria.

GitHub: Geocode-hub · X: @CoolRexy150983 · Instagram: @geocodedev · WhatsApp: +234 907 269 0451