How to build a JAMB CBT app

Building a JAMB CBT app requires more than displaying past questions on a screen. A useful UTME practice app needs structured question data, exam timing, subject selection, question navigation, automatic scoring, explanations and reliable handling of student progress.

The easiest way to approach the project is to separate it into two parts:

CBT Application
      +
Question Data

Your application handles the user experience, while a question-data source such as SdashAPI can provide structured UTME questions through an API.

1. Decide what your JAMB CBT app will do

Before writing code, define the first version.

A simple JAMB CBT app might include:

• User registration
• Subject selection
• Practice mode
• Timed mock examination
• Previous and Next navigation
• Question palette
• Automatic scoring
• Explanations after submission
• Result history

Don't try to build every possible feature at once.

Get the actual examination flow working first.

2. Choose your technology

You can build the application with almost any modern framework.

For mobile:

React Native
Flutter
Kotlin
Swift

For web:

React
Next.js
Vue
Angular

Your backend could use Node.js, PHP, Python, Java or another technology you're comfortable with.

A typical architecture is:

Mobile App / Website
        ↓
Your Backend
        ↓
Question API

This also keeps sensitive production API credentials away from public frontend code.

3. Get your JAMB question data

You now need actual UTME questions.

You have three main options:

Build the database yourself. You manually collect, structure, correct and maintain the questions.

License a dataset. You obtain structured data and store it in your own database.

Use an API. Your backend requests questions when needed.

SdashAPI provides an API-based option for developers who don't want to spend most of their development time manually building the question database.

For more detail on this part, see JAMB question bank for CBT app.

4. Connect your application to the question API

Your application should be able to specify what it needs.

For example:

Exam: UTME
Subject: Biology
Year: 2024
Limit: 40

Your backend sends the request and receives structured question data.

A simplified response could contain:

{
  "id": 89421,
  "question": "Which of the following is correct?",
  "option": {
    "a": "Option A",
    "b": "Option B",
    "c": "Option C",
    "d": "Option D"
  },
  "answer": "b",
  "solution": "Explanation of the answer.",
  "examtype": "UTME",
  "examyear": "2024"
}

Check the current request format and available parameters in the SdashAPI Documentation.

You can also read JAMB questions JSON API for the JSON-specific approach.

5. Build the question screen

Your main CBT screen should be simple.

For example:

Question 12 of 40                 21:45

Which of the following is...?

A. Option A

B. Option B

C. Option C

D. Option D

[ Previous ]              [ Next ]

Students should immediately understand:

• Which question they're answering
• Which option they selected
• How much time remains
• How to move between questions

Avoid overcrowding this screen with unnecessary features.

6. Add question navigation

Students should be able to move around the examination.

A question palette can show:

1  2  3  4  5
6  7  8  9  10
...

You can visually distinguish:

Answered
Not answered
Current question
Flagged for review

Store the student's selected answer against the question ID.

For example:

{
  "question_id": 89421,
  "selected_answer": "c"
}

This means moving to another question doesn't erase the previous answer.

7. Add the CBT timer

For mock examination mode, create a countdown timer.

When it reaches zero:

00:00
  ↓
Automatically submit examination

Save examination progress periodically so that a temporary application restart doesn't necessarily destroy the student's entire attempt.

Also, don't start the timer while you're still waiting for questions to download.

Prepare the session first, then begin the examination.

8. Add automatic scoring

When the student submits, compare their selected answers with the correct answers.

For example:

Total Questions: 40
Correct: 31
Incorrect: 9

Score: 77.5%

For serious mock-exam mode, avoid revealing correct answers while the examination is still active.

Your backend can handle grading if you don't want correct-answer information exposed to the client before submission.

9. Add explanations

After submission, allow students to review their answers.

For example:

Question 12

Your Answer: C
Correct Answer: B

Explanation:
[Explanation of why B is correct]

This is what turns the application from a simple quiz into a revision tool.

Where available, richer question data can also help you build topic and difficulty-based learning features.

10. Handle passages and images

Your interface should expect real examination questions to contain more than short text.

You may encounter:

• Long questions
• Long answer options
• Comprehension passages
• Mathematical expressions
• Diagrams
• Graphs
• Scientific illustrations

Test these early.

If a question contains an image, display it responsively and consider allowing the student to enlarge it.

For passages, provide an easy way to reopen the passage while answering related questions.

11. Add practice and mock modes

You don't have to make every session behave like an examination.

You could provide:

Practice Mode

No strict timer
See answer after each question
Read explanation immediately

Mock Exam Mode

Timed
No answers shown during examination
Results after submission

This gives students two different ways to use the same underlying question data.

12. Add revision features

Once the basic CBT works, useful additions include:

Questions I Got Wrong

Automatically save incorrectly answered question IDs.

Bookmarks

Allow students to save difficult questions.

Weak Topics

If topic metadata is available, calculate where the student performs poorly.

For example:

Biology Performance

Ecology          78%
Genetics         42%
Cell Biology     71%

You can then recommend additional Genetics practice.

13. Plan for poor internet connections

A CBT app should not become unusable because the student's connection drops for a few seconds.

Where your data usage arrangement permits it, prepare the examination session before starting and cache the required session data temporarily.

The flow becomes:

Internet available
      ↓
Prepare examination
      ↓
Questions ready
      ↓
Start timer
      ↓
Student completes session

This is much better than requesting another question from the server every time the student presses Next.

14. Test with real questions early

Don't build your entire application using only:

What is 2 + 2?

Real UTME questions will expose problems that dummy data won't.

Test:

• Long questions
• Long options
• Images
• Passages
• Explanations
• Mathematical content
• Different screen sizes
• Failed network requests

Your UI should survive all of them.

15. Use 2,000 free credits while developing

SdashAPI provides 2,000 free credits for development and testing.

You can use them while building your first version to test real API responses, question loading, filtering, scoring, explanations and other features.

A simple development flow is:

Create SdashAPI account
        ↓
Get 2,000 free credits
        ↓
Generate development API key
        ↓
Connect your CBT app
        ↓
Build and test

Start through SdashAPI.

When you're ready for actual users, you can create a separate production API key and choose an appropriate option through SdashAPI Pricing.

16. Check question coverage before launch

Before displaying every possible subject and year in your application, verify what data is actually available.

You can check current examination coverage through SdashAPI Coverage.

Ideally, your app should only show combinations that can return questions.

A simple JAMB CBT app architecture

Putting everything together:

Student
   ↓
React Native / Flutter / Web App
   ↓
Your Backend
   ↓
SdashAPI
   ↓
UTME Question Data

Meanwhile:

Your Database
   ↓
Users
Results
Bookmarks
Attempts
Subscriptions
Progress

This separation keeps things manageable.

Your database handles information belonging to your product and users. The examination API handles the question-data layer.

SdashAPI is an independent examination-data platform and is not an official JAMB service.

If you're building your first JAMB CBT app, start small: load real UTME questions, make answering and navigation work properly, add scoring and explanations, then expand into mock exams, analytics and personalised revision.

The goal isn't simply to recreate past questions on a phone screen. It is to build a CBT experience that helps students practise effectively.