Your Test, Your Rules: Create Custom Practice Tests with Examify

, , ,
MyServices Portal and Examify Logos

Unlock Personalized Learning by Crafting Your Own Question Sets in Examify

So, you've explored the MyServices Portal and discovered Examify, your new hub for realistic exam practice. While our growing library of official past papers is a great start, what if you want to drill down on specific topics, test yourself with questions you've collected, or even create quizzes for your study group or students?

That's where Examify's Custom JSON Exam feature comes in – giving you the power to define "Your Test, Your Rules!"

This guide will walk you through everything you need to know to create and use your own custom question sets in Examify, from understanding the simple JSON format to leveraging AI for assistance.

Why Create Custom Tests? The Power of Personalized Practice

Before we dive into the "how," let's quickly touch on the "why":

  • Target Weaknesses: Focus intensely on subjects or topics where you need the most improvement.
  • Consolidate Learning: Create tests from notes, textbook chapters, or questions you've gathered from various sources.
  • Unique Scenarios: Practice with question types or difficulty distributions not found in standard papers.
  • For Educators/Tutors: Quickly design quizzes, formative assessments, or topic-specific drills for your students.
  • Collaborative Creation: Study groups can collaboratively build question banks and share them.

The Anatomy of an Examify Question Set: Understanding questions.json

At its heart, every custom exam in Examify is defined by a simple JSON (JavaScript Object Notation) file. Don't let the term "JSON" intimidate you; it's just a human-readable way to structure data.

You can see the exact format we use for our official papers in our transparent, open-source Online Exam Questions GitHub Repository. This repository is also where you'll find our config.json, the master index Examify uses to list official tests.

Here's the basic structure of a custom question JSON file:

  1. It's an Array: The entire file content is a single JSON array, denoted by square brackets [].
  2. It Contains Question Objects: Each element inside this array is a JSON object {}, representing one question.

Each Question Object has the following fields:

  • Mandatory Fields:
    • question_number (Number): A unique integer for each question, starting from 1 and increasing sequentially (e.g., 1, 2, 3...).
    • question_text (String): The actual text of your question.
    • options (Object): An object where keys are option letters (e.g., "a", "b", "c") and values are the option text strings. You need at least two options.
    • correct_answer (String): The key of the correct option (e.g., "b"). This must exactly match one of your option keys.
  • Optional (But Recommended!) Fields:
    • subject (String): The subject of the question (e.g., "Mathematics", "Logical Reasoning").
    • topic (String): A more specific topic within the subject (e.g., "Trigonometry", "Syllogisms").
    • explanation (String): A detailed explanation for the answer. This is incredibly helpful for learning!
    • difficulty (String): Can be "Easy", "Medium", or "Hard".
    • section_id (String): If your test has sections, you can use this to group questions (e.g., "QuantitativeAptitude").

Example of a Single Question Object:

{
  "question_number": 1,
  "subject": "Mathematics",
  "topic": "Algebra",
  "question_text": "If $x + 5 = 12$, what is the value of $x$?",
  "options": {
    "a": "5",
    "b": "7",
    "c": "12",
    "d": "17"
  },
  "correct_answer": "b",
  "explanation": "Subtract 5 from both sides: $x + 5 - 5 = 12 - 5 \\implies x = 7$.",
  "difficulty": "Easy"
}

A complete questions.json file would look like this:

[
  {
    "question_number": 1,
    "question_text": "First question...",
    "options": { "a": "Opt A1", "b": "Opt B1" },
    "correct_answer": "b"
  },
  {
    "question_number": 2,
    "subject": "Physics",
    "question_text": "Second question...",
    "options": { "a": "Opt A2", "b": "Opt B2" },
    "correct_answer": "a",
    "explanation": "This is why 'a' is correct."
  }
  // ... more question objects
]

✨ Rich Content: Adding Math, Images, and Code

Your questions, options, and explanations aren't limited to plain text! Examify's custom JSON supports:

  1. Mathematical Notation (LaTeX via KaTeX):
    • Inline Math: Use single dollar signs: $E = mc^2$
    • Display Math (Block): Use double dollar signs: $$\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}$$
    • CRITICAL JSON Escaping: Inside your JSON string, every LaTeX backslash \ must be escaped with another backslash \\.
      • So, \frac{1}{2} becomes "$\\frac{1}{2}$" in your JSON.
      • And \sin(x) becomes "$\\sin(x)$" in your JSON.
  2. Images (Markdown Format):
    • Use the standard Markdown syntax: ![Alt Text](Image URL)
    • Supported URLs:
      • Absolute HTTPS URLs: Link directly to images hosted online (e.g., Imgur, your own server). Example: ![Diagram](https://i.imgur.com/yourimage.png)
      • Relative Paths (for Official Papers/Advanced Users): If you were contributing to our official GitHub question repo, you'd use relative paths like ExamCategory/assets/image.png. For your personal custom JSON uploads/pastes, it's generally easier to use absolute HTTPS URLs.
    • Provide descriptive Alt Text for accessibility.
  3. Chemical Content (LaTeX & Images):
    • For simple equations, use LaTeX math mode with escaped symbols: "$$CH_4 + 2O_2 \\rightarrow CO_2 + 2H_2O$$"
    • For complex structures, it's best to use an image and link it via Markdown.
  4. Code Snippets (Markdown Fenced Code Blocks):
    • Use triple backticks ```, optionally followed by the language (e.g., ```python).
    • CRITICAL JSON Escaping: Newlines within your code block must be escaped as \n.
    • Example in JSON: 
      "question_text": "What is the output of this Python code?\\n\\n```python\\ndef greet(name):\\n  print(f\"Hello, {name}!\")\\n\\ngreet(\"Examify\")\\n```"

Creating Your Custom JSON File: Step-by-Step

  1. Plan Your Test: Decide on the subject, topics, number of questions, and question types.
  2. Use a Plain Text Editor: Any simple text editor (like Notepad on Windows, TextEdit on Mac in plain text mode, VS Code, Sublime Text, Atom) will work. Avoid word processors like MS Word, as they add extra formatting.
  3. Start with the Basics:
    • Begin your file with an opening square bracket [.
    • End your file with a closing square bracket ].
  4. Add Your First Question Object:
    • Inside the [], add an opening curly brace { for your first question.
    • Add the mandatory fields: question_number (start with 1), question_text, options (as an object itself with key-value pairs), and correct_answer.
    • Add optional fields like subject, topic, explanation as needed.
    • Remember to enclose all string values in double quotes " and escape special characters within those strings (especially \ and " themselves, and newlines in code).
    • Close the question object with a closing curly brace }.
  5. Add More Questions:
    • If adding more questions, put a comma , after the closing brace } of the previous question object.
    • Then, add your next question object {...}.
    • Ensure question_number is sequential and unique for each question.
    • The last question object in the array should not have a comma after its closing brace }.
  6. Save Your File: Save the file with a .json extension (e.g., my_algebra_quiz.json).

Don't Want to Write JSON by Hand? Use Our Editor!

We've also developed a user-friendly Examify JSON Editor (React Version)! This tool provides:

  • An intuitive form-based editor.
  • A raw JSON editor with syntax highlighting.
  • Live previews of how your questions will look (including LaTeX and Markdown).
  • Comprehensive validation to help you catch errors.
  • Templates to get you started quickly.
  • Import/Export functionality.

It's the perfect companion for crafting your Examify question sets!

Download a Starter Template:

To make it even easier, here's a basic template you can download and modify:

Download questions_template.json

This template includes a couple of example questions with different fields.

Validating Your JSON

Before uploading to Examify, it's a good idea to validate your JSON to ensure it's correctly formatted. Many online tools can do this (search "JSON validator"). Our Examify JSON Editor also has built-in validation.

Common errors include:

  • Missing commas between question objects (but not after the last one).
  • Unmatched brackets [] or braces {}.
  • String values not enclosed in double quotes.
  • Special characters within strings not properly escaped (like " needing to be \", or \ in LaTeX needing \\, or newlines in code blocks needing \n).

Using Your Custom Exam in Examify

Once your questions.json file is ready:

  1. Log in to your MyServices Portal at bcaexamprep.web.app.
  2. Navigate to Examify from your dashboard.
  3. On the "Select Your Practice Mode" page, under "Individual Practice," choose the "Custom Test (Upload or Paste)" option.
  4. You have two choices:
    • Upload File: Click "Choose JSON File," select your saved .json file. Examify will attempt to parse and validate it.
    • Paste JSON Code: Click "Paste JSON Code," paste your entire JSON content into the text area, and then click "Validate Pasted JSON."
  5. Error Handling:
    • If there are syntax errors in your JSON, Examify will display an error message. Go back to your editor, fix the issue, and try again.
    • If the JSON is syntactically valid but doesn't match the Examify question structure (e.g., missing question_text or invalid correct_answer key), you'll also receive specific error messages.
  6. Success! If your JSON is valid and passes structural checks, you'll see a success message (e.g., "File ready!" or "Validated JSON is ready.").
  7. Configure & Start: Click "Start Individual Session." You'll then be prompted to configure settings like time limit and marking scheme before beginning your custom test.

Tips for Creating Great Custom Questions

  • Clarity is Key: Ensure question text and options are unambiguous.
  • Plausible Distractors: Make incorrect options believable but clearly wrong.
  • Vary Difficulty: Mix easy, medium, and hard questions if creating a larger set. Use the difficulty field!
  • Comprehensive Explanations: The explanation field is your chance to teach. Explain why the correct answer is right and, if useful, why others are wrong.
  • Test Thoroughly: After creating, take the test yourself in Examify to catch any errors or awkward phrasing.
  • Leverage AI (Carefully!):
    • AI tools (like ChatGPT, Claude, Perplexity) can help generate question ideas or even draft initial JSON, but you MUST prompt them very carefully regarding the structure, LaTeX escaping (\\), and code block newline escaping (\n).
    • Always meticulously review and validate AI-generated JSON. AI makes mistakes, especially with complex formatting and ensuring sequential question_numbers.
    • Use the AI prompt provided in our Online Exam Questions GitHub Repository README as a strong starting point.

Take Control of Your Learning

Examify's custom JSON exam feature puts you in the driver's seat of your preparation. By creating tests tailored to your needs, you can address weaknesses, reinforce strengths, and build the confidence to excel.

So, grab that template, fire up your text editor (or our Examify JSON Editor), and start crafting the practice sessions that will lead you to success!

What are your favorite ways to use custom tests?

Go to Examify Now!

Related Posts

Contact Form

Name

Email *

Message *