You open a new authoring tool, add a button, and the properties panel offers you triggers, states, layers and variables all at once. It can feel like learning a programming language when you only wanted the button to show some feedback. The model behind it is smaller than it looks, though, and once it clicks you can build almost any interaction from the same few pieces. What do triggers, states and layers actually do, and how can they make an interaction teach instead of decorate?
Triggers, states and layers are the three building blocks of most slide-based e-learning interactions: a trigger says what happens and when, a state is a version of an object's appearance, and a layer is extra content that appears on top of a slide. A trigger listens for an event, such as a click, checks any conditions you set, and then performs an action, such as changing a state or showing a layer. Variables add memory, so the course can react to what the learner did earlier. Used well, they let a learner's choice change what happens next, and that is what separates teaching from decoration.
What Are Triggers, States and Layers?
Think of a single slide as a small stage. The objects on it are the actors, states are their costume changes, layers are scenes that slide in over the main set, and triggers are the stage directions that tell everything when to move. You will find this event, state and layer model in many slide-based tools, including Articulate Storyline and others, so the habits you build here travel with you.

Here is how the three relate in plain terms:
- A trigger connects an event (the learner clicks, the timeline reaches a point, a variable changes) to an action (show a layer, change a state, jump to a slide, adjust a variable).
- A state is a stored look for one object, such as normal, hover, down, selected, visited or disabled, plus any custom states you design.
- A layer holds content that appears over the base slide, such as feedback, a hint or a pop-up detail, without sending the learner to a new slide.
How Does a Trigger Decide When to Fire?
A trigger fires when its event happens and all of its conditions are true. That sentence covers most of the logic you will ever write. The event is the "when," the action is the "what," and the condition is the optional "only if."
Try reading every trigger aloud as one sentence. "When the learner clicks Submit, show the Correct layer, only if the answer variable equals B." If you cannot say it in one breath, the trigger is probably doing too much, and splitting it into two clearer triggers will save you hours of debugging later.
Conditions are where beginners get tangled, so keep them readable. "Only if Score is at least 3 and Attempts is less than 2" is fine. Once you find yourself stacking four or five conditions with a mix of "and" and "or," the trigger has become a puzzle that even you will struggle to read next month. Usually that means a variable is missing, such as a single "readyToContinue" flag that other, simpler triggers set along the way.
It also helps to know the common events by name, because each one suits a different teaching moment:
- A click or tap, for choices and exploration.
- The timeline reaching a point, for revealing steps in sync with narration.
- A variable changing, for reacting to progress the learner made elsewhere.
- An object being dropped on a target, for sorting and matching practice.
Order matters too. When several triggers listen for the same event, many tools run them in the order they are listed, so check how yours behaves. If one trigger jumps to another slide before the next one updates the score, the score never changes. When something mysteriously does not happen, check the order before you check anything else.
What Are Object States Good For?
States are good for showing the learner, at a glance, what has changed. A visited state on a menu tab tells learners where they have already been. A selected state on an answer choice confirms what they picked. A disabled state on the Next button says "not yet," which is kinder than a button that silently does nothing.
Custom states are where your design thinking comes in. Imagine a learner examining a piece of equipment on screen. Each part they inspect could switch to a "checked" state with a small mark, so they can see their own progress through the inspection. The state is doing teaching work there, because it reinforces the routine you want them to follow on the job.
One caution: states that change only color can leave some learners behind. Pair color with a shape, icon or text change so the meaning comes through for everyone.
When Should You Use a Layer Instead of a New Slide?
Use a layer when the new content belongs to the same moment, and use a new slide when the learner is moving on. Feedback on a choice, a hint, a close-up of a diagram or the explanation behind a hotspot all belong on layers, because the learner still needs the base slide for context.
A new slide makes more sense when the topic shifts, when the content needs its own navigation, or when you want the LMS to record it as a distinct point in the course. A good rule of thumb: if the learner would want to close the extra content and keep working on the same screen, it is a layer.
Layers also make a great home for consequences. Instead of one generic "Incorrect" layer, build a layer for each wrong choice that shows what that choice would lead to. That small change turns a quiz question into a lesson.
How Do Variables Make Interactions Remember?
Variables let a course remember what the learner has done so later triggers can respond to it. A true/false variable can track whether a learner has opened the safety tab. A number variable can count attempts or points. A text variable can hold a name the learner typed and use it later in feedback.
Here is a small made-up example. A learner explores four hotspots on a warehouse diagram. Each hotspot sets its own true/false variable when clicked. The Continue button starts in its disabled state, and one trigger changes it to normal only if all four variables are true. You have built a "look at everything first" rule without any scripting, and the button's state tells the learner exactly where they stand.
Variables also let you add support without punishing anyone. Count wrong attempts, and when the count reaches two, show a hint layer. The learner who gets it right away never sees the hint. The one who is struggling gets help at the right moment.
In AuthorLearn Studio, triggers are written as plain sentences, such as "When the learner clicks Button 2, show layer Hint if Score < 3." That makes the read-it-aloud test above part of the tool itself, and the debug panel in preview shows variables and trigger events as you click through.
How Do You Keep Interaction Logic From Turning Into Spaghetti?
You keep logic tidy by naming things well, keeping each trigger small, and planning the logic before you build it. Spaghetti logic rarely comes from one bad decision. It grows from dozens of quick fixes on objects named "Rectangle 14."
- Name every object, layer and variable for what it means, such as "btnSubmit" or "attemptsCount," not what it looks like.
- Sketch the logic in a sentence or a small table before you build. If the sketch is confusing, the build will be worse.
- Keep one job per trigger. Two clear triggers beat one clever one.
- Test with a keyboard as well as a mouse. Under WCAG, all functionality should be operable from a keyboard, and custom interactions are where that most often breaks.
- Reset what needs resetting. If a learner can revisit the slide, decide whether states and variables should start fresh or keep their earlier values.
When an interaction grows past a handful of decisions that lead to different paths, step back. You may be building a branching scenario one trigger at a time, and it deserves its own map before you go further.
Triggers, States and Layers Should Change What the Learner Thinks, Not Just What They See
Triggers, states and layers are simple tools: an event and an action, a stored look, a panel on top. What makes them powerful is using them so that a learner's choice leads somewhere meaningful, such as feedback tied to their specific mistake, a hint that appears only when it is needed, or a state that shows progress through a real routine.
Start small. Build one interaction with a single variable and two feedback layers, read every trigger aloud, and test it with your keyboard. Once that feels comfortable, you will find you can design the learning first and trust that the mechanics will follow.
