As Instructional Designers, we must have a basic awareness of the different types code files we come across. Although we are seldom required to handle these files directly, the terms “JSON,” “XML,” “HTML,” “CSS,” shouldn’t make us scratch our heads. We should recognize them, as we would recognize people who live in our vicinity 🙂

Right at the start of this post, I’d like to tell you that I am no coder. I am at BL1 (I can recognize files by their tags and structures), and if I stretch myself to the breaking point, I can understand the general purpose for which a file has been created. So, with that little disclaimer in place, let us immerse ourselves in the glamor of JSON.

If you work in the elearning industry, you must be aware that xAPI is used to help us store and retrieve information on how our learners perform when they take our courses and trainings.

Let us now assume that two learners, Aarav and Aditi, take an online course on fiction-writing. Here’s some information that we’ll see “codified” as JSON or JavaScript Object Notation.

Following is the content of our hypothetical course.

  • Course: Fiction Writing
  • No. of Modules: 2
    • Module 1 – Story Fundamentals
      • Lesson 1: Plot Basics
      • Lesson 2: Conflict & Stakes
      • Lesson 3: Point of View
      • Lesson 4: World Building
    • Module 2 – Characters & Dialogue
      • Lesson 1: Character Arcs
      • Lesson 2: Dialogue Writing
      • Lesson 3: Subtext Injection
      • Lesson 4: Scene Crafting

And here are our learners and how they’ve progressed through the course.

Module & LessonAditi’s Completion %Aarav’s Completion %
Module 1-Lesson 1100%80%
Module 1-Lesson 270%100%
Module 1-Lesson 30%60%
Module 1-Lesson 4100%20%
Module 2-Lesson 190%100%
Module 2-Lesson 2100%100%
Module 2-Lesson 340%90%
Module 2-Lesson 40%70%

So, how would the JSON code for the above look like?

{
  "course": {
    "id": "course-fiction-writing",
    "title": "Fiction Writing",
    "modules": [
      {
        "id": "module-1",
        "title": "Story Fundamentals",
        "lessons": [
          { "id": "m1-l1", "title": "Plot Basics" },
          { "id": "m1-l2", "title": "Conflict & Stakes" },
          { "id": "m1-l3", "title": "Point of View" },
          { "id": "m1-l4", "title": "World Building" }
        ]
      },
      {
        "id": "module-2",
        "title": "Characters Arcs",
        "lessons": [
          { "id": "m2-l1", "title": "Character Arcs" },
          { "id": "m2-l2", "title": "Dialogue Writing" },
          { "id": "m2-l3", "title": "Subtext Injection" },
          { "id": "m2-l4", "title": "Scene Crafting" }
        ]
      }
    ]
  },

  "learners": [
    {
      "name": "Aditi",
      "email": "aditi@example.com",
      "progress": {
        "module-1": { "m1-l1": 100, "m1-l2": 70, "m1-l3": 0, "m1-l4": 100 },
        "module-2": { "m2-l1": 90,  "m2-l2": 100, "m2-l3": 40, "m2-l4": 0 }
      },
      "updatedAt": "2025-09-02T07:10:00Z"
    },
    {
      "name": "Aarav",
      "email": "aarav@example.com",
      "progress": {
        "module-1": { "m1-l1": 80,  "m1-l2": 100, "m1-l3": 60, "m1-l4": 20 },
        "module-2": { "m2-l1": 100, "m2-l2": 100, "m2-l3": 90, "m2-l4": 70 }
      },
      "updatedAt": "2025-09-02T08:20:00Z"
    }
  ]
}

Pretty easy to see how the data maps to its JSON file, right?
Thus, there’s the actor (Aditi or Aarav – or the learner), the verb (Progress), the object (the lesson with its name), and the result (how much of it was completed.)

The above is, of course, static data put together to give you an idea of what the structure of a JSON file looks like.

When the data is dynamically recorded, the records look somewhat different, but you’d recognize the actor, verb, object, and result in the dynamic data too. Here’s an example of such dynamically generated code (courtesy: ChatGPT.)

[
  {
    "actor": { "name": "Aditi", "mbox": "mailto:aditi@example.com" },
    "verb": { 
      "id": "http://adlnet.gov/expapi/verbs/progressed", 
      "display": { "en-US": "progressed" } 
    },
    "object": {
      "id": "https://lms.example.com/courses/fiction-writing/module-1/lesson-1",
      "definition": { "name": { "en-US": "Plot Basics" } }
    },
    "result": {
      "extensions": {
        "https://lms.example.com/xapi/extensions/percentCompleted": 100
      }
    },
    "timestamp": "2025-09-02T07:10:00Z"
  },
  {
    "actor": { "name": "Aditi", "mbox": "mailto:aditi@example.com" },
    "verb": { 
      "id": "http://adlnet.gov/expapi/verbs/progressed", 
      "display": { "en-US": "progressed" } 
    },
    "object": {
      "id": "https://lms.example.com/courses/fiction-writing/module-1/lesson-2",
      "definition": { "name": { "en-US": "Conflict & Stakes" } }
    },
    "result": {
      "extensions": {
        "https://lms.example.com/xapi/extensions/percentCompleted": 70
      }
    },
    "timestamp": "2025-09-02T07:12:00Z"
  },
  {
    "actor": { "name": "Aarav", "mbox": "mailto:aarav@example.com" },
    "verb": { 
      "id": "http://adlnet.gov/expapi/verbs/progressed", 
      "display": { "en-US": "progressed" } 
    },
    "object": {
      "id": "https://lms.example.com/courses/fiction-writing/module-1/lesson-1",
      "definition": { "name": { "en-US": "Plot Basics" } }
    },
    "result": {
      "extensions": {
        "https://lms.example.com/xapi/extensions/percentCompleted": 80
      }
    },
    "timestamp": "2025-09-02T07:25:00Z"
  }
]

So that’s what a snapshot of the JSON in the LRS might look like 🙂
Warning: As ChatGPT says, it can make mistakes – so don’t go through the above JSON code for its completeness or accuracy.

But now, what the heck is LRS?

What is LRS or the Learning Records Store?

An LRS or a Learning Records Store is a database that continuously records the actions of the learners, in statements such as the ones we see above; each with the actor, the verb, the object, and the result. Later, data may be retrieved for an entire class of students (how many students finished a 100% of at least one of the two modules,) or for a specific module (to find how many students finished more than 80% of it,) or anything that the instructional designer or instructional analyst considers important.

Why must an instructional designer be aware of what code “looks” like?

If you are still wondering why you must get an idea of what Mr. JSON looks like… the answer is – It helps to get the whole picture. Knowing how you fit into the larger puzzle allows you to plan, design, and interact better. For instance, if you are pushing data in say, Articulate, by selecting Publish → Reporting and Tracking, and choosing SCORM or xAPI (The Tin Can), you know why you are doing it. When you say, “When user clicks Submit button, send statement “answered” to the LRS,” by selecting the verb (answered), the activity (the quiz), and the result (the score), you know what’s actually happening at xAPI’s end.

Knowing what you are doing and why you are doing it empowers you.

This is why you must develop your peripheral knowledge. You don’t have to build these files (they are built automatically,) and in the future, you may have AI helping you analyze the LRS (Learner Records Store) information to draw conclusions, but knowing what it looks like will make you feel at home with your work 🙂