I’ve been doing a lot of work lately reviewing Microsoft 365 learning programmes at work, and experiencing learning Claude for my own curiosity. Videos, activities, the whole journey from “what even is AI or LLM” through to “here’s how to build a Skill or work with Agents.”
And while mapping out the activities this week, I found myself thinking about something that doesn’t come up enough in conversations about technology training.
We talk a lot about adoption. We talk about change management, about user readiness, about getting people to actually use the tools they’ve been given. But we don’t often talk about the depth of learning that has to happen for any of that to stick.
That’s what I want to get into here.
A framework that changed how I think about learning design
SOLO taxonomy. If you haven’t come across it, it stands for Structure of Observed Learning Outcomes. It was developed by researchers John Biggs and Kevin Collis back in 1982, originally for academic education, but it maps so cleanly onto workplace training that I keep coming back to it.
The idea is simple: learning isn’t binary. It’s not “they know it” or “they don’t.” It moves through levels, and each level represents a qualitatively different kind of understanding.
The levels are:
Prestructural – the learner hasn’t engaged, or has missed the point entirely.
Unistructural – they can recall one thing. One step, one fact, one idea. A foundation, but not yet useful on its own.
Multistructural – they know several things. But the pieces aren’t connected yet.
Relational – they understand how the pieces fit together and can apply that to their own context. This is where behaviour starts to change.
Extended abstract – they can generalise beyond the lesson, transfer the concept to situations that weren’t covered, make their own judgements.
Most workplace training sits at multistructural and stops there. People finish a course knowing things. They just don’t know what to do with them.
What this looks like in practice
Let’s explore this through what might be in a OneDrive course.
At the Know phase, a learner might work through a comparison table – traditional file storage on one side, cloud storage on the other. Floppy disks versus OneDrive. One version at a time versus automatic version history. It’s clear, it’s simple, and it lands somewhere around multistructural. Several ideas, laid out helpfully, not yet connected to anything the learner does.
At the Do phase, the activity shifts. A fill-in-the-blank check asks the learner to recall the exact steps for accessing OneDrive from a browser. It’s constrained, close to unistructural, but it asks the learner to retrieve rather than just recognise. That matters for memory in a way that re-watching a video doesn’t.
Apply is where things get more interesting. A matching activity asks learners to connect real work scenarios to the OneDrive feature that addresses them. Editing a presentation on your phone before a meeting – that maps to accessing files on any device. Making changes on the train and seeing them reflected at your desk – that’s real-time sync. The learner isn’t being told what’s relevant. They’re working it out.
That’s relational thinking. And it’s where the understanding starts to become something you can actually use.
Reflect pushes further. A prompt asking learners to notice over the coming week where they take photos of whiteboards or documents – and to consider how capturing those directly into OneDrive might change how they store and share work – isn’t asking for recall at all. It’s asking them to think ahead. To imagine a situation that hasn’t happened yet and apply what they’ve learned to it.
That’s extended abstract territory. And in a workplace training context, that’s where genuine behaviour change lives.
Why this matters for adoption
I’ve sat in enough post-rollout reviews to know the pattern. Training completion rates look fine. Tool usage metrics don’t match.
People finished the courses. They just didn’t change how they work.
When you dig into why, the answer is almost always that the training introduced the features but never built the relational understanding needed to make them mean something. Learners could describe version history. They hadn’t connected it to the anxiety of overwriting a colleague’s work. They knew what the sync icons looked like. They hadn’t thought about what they’d do if they needed a file and had no internet.
The knowledge was there. The connection to their actual working day wasn’t.
And that gap – between knowing and doing – is a learning design problem, not a communications problem. You can’t send enough reminder emails to close it.
The activities matter as much as the content
This is the thing that gets underfunded in most technology training programmes: the thinking about what learners actually do with what they’ve watched.
A video is not enough. Not because video is bad, but because watching something is almost always a multistructural experience at best. You see the feature. You understand it exists. You couldn’t yet apply it under pressure in a real situation.
The activity alongside the video is what moves the learner up the SOLO levels. And not all activities do that equally.
Comparison tables are great at multistructural – they organise new concepts against familiar ones and give people something to hold onto. Flash cards help with recall. Fill-in-the-blank checks encourage retrieval rather than just recognition.
But matching activities that require genuine judgement, reflection prompts that ask learners to think beyond the lesson, key concept reinforcement that isolates the idea most likely to change a habit – those are the activities that build relational and extended abstract understanding.
They’re also the activities that get cut first when time or budget is tight.
A note on sequencing
One thing I want to be clear about: SOLO levels aren’t a hierarchy to rush through.
Unistructural and multistructural activities are valuable. They build the foundation that relational learning needs. A programme that skips straight to “reflect on how this changes your practice” without first giving learners the conceptual grounding will lose people.
The levels exist in sequence for a reason. The goal isn’t to get to extended abstract as fast as possible. It’s to take learners through each level deliberately, so that by the time you’re asking them to transfer and apply the learning, they actually have something to draw on.
What I keep coming back to
When I look at the activities in the OneDrive programme we have in our learning platform, or ways I am succeeding with learning Claude, I can map them against SOLO to think about the levels and the experience I am having. What strikes me isn’t just that the levels are covered. It’s that they’re covered intentionally.
The Know phase earns its multistructural activities. The Do phase earns its unistructural retrieval checks. The Apply phase earns its relational matching. The Reflect phase earns its extended abstract prompts.
That’s not accidental. It’s the result of thinking carefully about what learners need to be able to do at each stage, not just what they need to know.
And it’s the difference between training that ticks a box and training that actually changes how people work.
That’s what I think about when I talk about learning design. Not just the content. The cognitive journey.