This solution covers how to create a Learnosity-powered blended learning product, driven by our embedded authoring APIs for Item & Activity creation.

• Learning & assessment platforms.
• Test prep platforms.
• Diagnostic & benchmark test platforms.

• Have in-house and potentially teacher-created content.
• Have an in-house content management system with a need to extend that experience.
• Want to deliver a test or form-based experience — whether that's fixed form or adaptive.

A company, Megadodo Publishing (who we’ll call MegaPub), is a large publisher looking to integrate assessments within their articles. These articles are used as educational tools within many K12 and college level schools. Traditionally, reading the article and then answering Questions about it has been two separate processes but using Learnosity, MegaPub is looking to integrate it.

MegaPub is looking for a way to integrate assessments within their articles. They would like to:

1. Add a powerful Item authoring experience to allow their users to create their own content.
2. Add many more Technology Enhanced Items (TEIs) to their assessments.
3. Embed these TEIs within the articles they publish.
4. Have a deep understanding of the data around their assessments.

MegaPub can achieve all of this by using the Learnosity APIs. We will walk through an example where MegaPub has used:

Author API

• Embeds an Item editing tool within MegaPub’s platform.
• Gives their teachers the ability to author 65 different Question types.
• Gives their teachers access to Features, like video and audio players.
• Allows MegaPub to limit the teachers to only see what they themselves have created, or allows them to select from MegaPub’s entire Item bank.
• Allows teachers to apply Tags to each Item, which can be used for sorting and reporting.
• Saves all content to Learnosity’s servers.

Items API

• Embeds Items for students to answer directly within MegaPub’s content.
• Pulls down content from MegaPub’s Item bank, hosted on Learnosity’s servers.
• Saves the student’s work, and submits it to the Learnosity servers for scoring.

Reports API

• Embeds reports designed for student and teachers within MegaPub’s platform.
• Calculates what information to show and puts the UI (User Interface) on the page.
• Can be called without UI for custom styled reports.

The first step for MegaPub is to embed the Author API wherever their teachers will need to create content. In their platform, after a instructor logs in, the user has the option of navigating to a page where they can manage their assessments. Here the Author API is initialized, embedding it within the page. MegaPub can use the Author API’s Activity builder to allow the user to build tests from the Items in MegaPub’s Item bank, allow the user to make their own content, or both. The user never has to switch over to a new site or even know about Learnosity — they just assume these tools are built by MegaPub.

Figure 2: embedding Author API.

On initialization, MegaPub can hand some basic information to Learnosity’s Author API about how they want the embedded authoring solution to appear to this particular teacher. Learnosity also needs to know the user ID of this author, though it is one of MegaPub’s choosing, and contains no personal information whatsoever.

Figure 3: the MegaPub database provides the user IDs to Author API.

Once the initialization is complete, most of the heavy lifting is now done by Learnosity. The Author can interact with the embedded authoring solution. Once they’ve built or edited their first Item and are satisfied, they hit save.

Figure 4: Item data is stored in the Learnosity hosted Item bank.

At this point, all the Item data is sent to Learnosity’s database and saved to MegaPub’s Item bank. Rather than having to save all the Item JSON or media files themselves, MegaPub only has to save the Item’s reference, which they will use to identify it later when they want to put it in front of the student.

With Items created and stored in the MegaPub Item bank, they can now be presented to students as assessments. Just like the Teachers, they will log on and have a way to navigate to an assessment part of the platform. Once they’ve selected which test they’d like to take, they are brought to a page where the Items API is initialized. MegaPub is going to use the Items API in inline mode so that the Items that appear are embedded throughout the articles they've created.

Figure 5: embedding Items API.

Just like with the Author API, MegaPub will need a user ID so they can get the student’s information later. Just as before, absolutely no personally identifying information is used. They'll also need to pass all those Item IDs we saved before — along with instructions for the Items API on how to appear for this student. This will automatically pull down all the relevant information around the authored Items in MegaPub’s Item bank. Each of these Items is rendered individually, wherever MegaPub chooses.

Figure 6: the MegaPub database provides the user ID and Item references to Items API.

As before, now that we’ve initialized the API, Learnosity can do most of the heavy lifting. As the student interacts with their Activity, they can save their work or submit it for final grading. Both of these processes are handled entirely by Learnosity. The only thing MegaPub has to do is note that the student has completed the Activity, and so they should save the session and Activity IDs for reporting. MegaPub will use the session ID to identify this particular instance of this student taking the Activity, while they will use the Activity ID as a way of identifying all the instances between all the students who have taken this Activity. Using a combination of these three IDs, they can easily get any set of data they need.

Figure 7: student answers are stored in the Learnosity student response database.

Let’s recap what’s been created so far. MegaPub has added Learnosity’s Author API to their authoring environment, letting Learnosity handle and store all the authored Items. MegaPub just has to store the Item IDs on their side. Then, when it’s time to show Items to students, they just need to pass a few relevant IDs from their side along with the Item IDs for Learnosity to render the assessment experience.

Finally, MegaPub has to think about Analytics. MegaPub is going to start with Learnosity’s Reports API. Like the Author API and the Items API, the Reports API will render Learnosity reports right in MegaPub’s environment. Once a user has navigated to the right place in MegaPub’s platform, the Reports API can be used to render reports on the page.

Figure 9: embedding Reports API.

The IDs MegaPub saved from the last step, during the Assessment experience, can now be passed to the Reports API. The user ID can be used to get reports on individual students, while the session and Activity IDs identify different sets of Activities taken.

Figure 10: the MegaPub database provides user IDs, and the Learnosity student response database provides the report data.

MegaPub now can choose from a multitude of different reports to display to the user — from seeing a review of every Question, to an overview of all the students in a classroom.

By using this workflow, MegaPub was able to allow their authors to create 65 different Question types, deliver tests to millions of students, and get detailed reporting — all without the user ever having to leave their environment. And the only thing MegaPub had to store on their side were a handful of references and IDs.

Return to the index of technical solutions.