Build a Cleaner Software Training Lesson in Rise

Software training can quickly get overwhelming when learners have to memorize terminology before they understand the job they’re trying to do. This Rise build takes a better path: start with the workflow, then use the interface details as support.

Behind the Build: Professional, Practical Software Training

In this Behind the Build walkthrough, Maestro senior LXD Brianna Hayes rebuilds a software-training lesson called “Writing a Call Note” for a fictional logistics company, Trellis Logistics. The audience is sales employees learning the basics of a CRM, but the design choices are useful for almost any practical systems training: professional branding, clean layout, realistic practice context, and just enough software navigation to help learners complete the task.

Start with the workflow, not the software tour#

The biggest instructional design move in this build happens before any block gets added.

Brianna’s older version of this kind of course spent a lot of time defining basic terms and introducing the CRM’s main navigation. That information wasn’t wrong, but it created a long runway before learners understood why any of it mattered.

For the rebuilt lesson, the goal is tighter:

You need to enter this call note. Here are the best practices. And, by the way, these are the buttons you’ll click while you do it.

Instead of making “learn the CRM” the whole lesson, the CRM becomes the environment where the real skill happens: writing a useful call note.

If you’re building your own Rise software training, use this as your first design checkpoint:

1. Name the real workplace task learners need to complete.
2. Identify the software actions required to complete that task.
3. Treat navigation and interface details as enabling objectives, not the main event.
4. Build the lesson around realistic inputs learners would actually use on the job.

In this case, the input is a customer call. The output is a well-written call note.

Step 1: Replace the native lesson title with a designed header#

For this lesson, Brianna turns off the native Rise lesson title and designs the title directly in the course instead. That gives the opening screen more control over tone and layout.

The visual direction is intentionally professional, clean, and minimal. That’s a useful constraint for many L&D teams: not every brand is playful, informal, or illustration-heavy. Sometimes the job is to make formal training feel polished without making it loud.

Here’s the header approach shown in the build:

1. Turn off the default Rise lesson title.
2. Add a Mighty Studio custom card block at the top of the lesson.
3. Place the lesson title text and the hero image inside the card.
4. Set the card to full screen width.
5. Add a gradient fill to the card, moving from a dark blue to a light teal.
6. Set the card corners to 0 radius so the edges feel square and flush with the course container.

The square corners are a small detail, but they do a lot. Rounded corners would make the card feel like a contained component. Zero-radius corners let the header feel like it spills onto the edges of the lesson.

Step 2: Use opposing gradients for depth in one block#

Here’s the fun part of the header: the card itself has one gradient, and the block background behind it uses a gradient in the opposite direction.

That creates a layered effect without adding extra blocks.

The setup looks like this:

1. In the custom card, keep your title and image inside the card area.
2. Apply the main gradient to the card background.
3. Apply a second gradient to the block background behind the card, running in the opposite direction.
4. Increase the block padding so the background gradient becomes visible above and below the card.
5. Set the padding to 20 for a subtle reveal.

In the video, Brianna demonstrates that increasing the padding does not change the size of the card itself. It expands the background area around it. If the padding were set to 0, the reverse gradient would disappear entirely.

That’s a handy trick when you want more visual depth but don’t want to stack multiple decorative blocks just to get there.

Variation: Turn the same treatment into a section header

Later in the course, Brianna reuses the same custom card treatment for a section header. Rather than rebuilding from scratch, she copies the original block and adjusts it.

For the section header version:

1. Copy the original custom card block.
2. Remove the image.
3. Keep the coordinated gradient treatment.
4. Apply padding only to the bottom so the background reads more like a bottom border.

This gives the lesson and section headers a shared visual language without making every header identical.

Step 3: Create a branded image treatment in Figma#

The hero image is based on the Trellis Logistics brand. In Figma, Brianna creates a treatment inspired by the company’s logo rather than dropping in a plain stock photo.

The image treatment is built from:

• Equal-size rectangles with consistent spacing
• A simple repeating pattern
• A stock image masked inside the custom shape
• Additional vertical line elements layered over the masked image
• Removed fills on some foreground shapes so the pattern appears to weave in front of and behind the image

That last move is what makes the image feel more custom. The masked photo stays constrained to the shape, while the vertical elements create a subtle “woven” effect connected to the brand system.

You don’t need this exact Figma setup for every course. The bigger idea is to pull one recognizable behavior from the brand, then use it to make stock imagery feel intentional.

Step 4: Replace a plain comparison with a CRM-inspired block#

The lesson opens with a hook: a contrast between a well-written call note and a poorly written one.

Brianna first considered building this with a simple columns block. That would have worked, but it would have missed an opportunity. Since this is software training, she decided to hint at the CRM interface learners will be using.

The final version uses a custom Mighty Studio template that resembles the CRM context and displays the notes side by side.

To recreate the pattern:

1. Start with the instructional purpose: compare a strong example and a weak example.
2. Instead of using a generic two-column text layout, frame the examples in a UI-inspired structure.
3. Build the custom block so the text fields remain editable.
4. Include only the fields needed for this course and workflow.

Brianna notes that this block was specific to the Trellis CRM example, so she did not share it to the Mighty Studio Discover library.

Step 5: Give the page more breathing room#

Throughout the lesson, the blocks are set to a larger size so the page feels less cramped.

The settings and choices called out in the video include:

1. Set blocks in the lesson to large for more breathing room.
2. Add a Mighty transition block between sections.
3. Use the line option for the transition.
4. Set the transition size to large so it aligns with the rest of the layout.
5. Increase the line thickness slightly.

Nothing flashy is happening here. The point is consistency. If your main content blocks are wide and spacious, your dividers should feel like they belong to that same system.

Step 6: Use Mighty Studio columns for tighter layout control#

For one content section, Brianna uses a Mighty Studio columns block instead of the native Rise columns block. The reason is control. The Mighty Studio version gives more precise control over:

• The space between columns
• How the columns distribute across the page
• The overall feel of the layout

This is one of those practical production choices that matters when you’re working with a formal brand. Small spacing issues can make a clean design feel slightly off, even when the content is strong.

Step 7: Make Continue buttons stand out with Mighty Mods#

Rise sometimes applies the course theme color to buttons in a way that doesn’t create enough emphasis for a specific interaction.

In this build, Brianna uses Mighty Mods to change the color of the Continue buttons so they stand out more than the default Rise styling allowed.

The move is simple:

1. Identify the Continue buttons that need more visual emphasis.
2. Use Mighty Mods to override the button color.
3. Choose a color that works with the brand palette and creates clearer contrast.

This is a good place to keep accessibility in mind. If you’re changing button colors, check that the text-to-button contrast is still strong enough and that the button remains easy to identify for learners scanning the page.

Step 8: Build the call context before the practice activity#

The next section is about the call itself. Its job is to reinforce a skill learners have presumably practiced before: conducting customer calls. It also gives them the input they’ll need for the later call-note activity.

Brianna builds the opening part of this section with a simple image and text block, then adjusts it with Mighty Mods:

1. Add an image and text block.
2. Use Mighty Mods to make it extra large so it fills more space.
3. Set the alignment to end so the text hugs the bottom edge of the block.

That bottom alignment helps the text feel connected to the navigation text that follows underneath.

Step 9: Use a custom card as invisible layout scaffolding#

One especially practical trick in this build is using a custom card block without making it look like a card.

Brianna wanted a piece of navigation text to be extra large width. A standard Rise paragraph block only goes up to large, so she used a Mighty Studio custom card instead.

Here’s the setup:

1. Add a custom card block.
2. Set the card width to extra large.
3. Remove the fill.
4. Remove the border.
5. Remove any visible card styling.
6. Use it purely to hold the navigation text at the width you need.

As Brianna says, sometimes you do what you need to do to make everything look cohesive. This is a good example of using a block for layout control, not because you want the default visual treatment.

Step 10: Add a phone-call-style branching conversation#

The call itself uses a branching conversation block that Brianna built and shared in the Mighty Studio Discover library.

The reason for building a custom version was specific: many chat-style blocks already exist, but they often mimic a text message or web chat interface. For this lesson, the interaction needed to feel like a phone conversation, not a chat app.

The block is designed to keep the focus on the conversation itself, with subtle animation that moves the dialogue forward.

If you pull this block from Discover, note that it includes multiple style options:

• Filled, with a solid fill behind each chat bubble
• Outlined, with an outlined bubble treatment
• Elevated, with shadow and added depth

Why this build works#

The lesson feels polished, but the polish is serving the instructional design. Each design choice supports one of three goals:

• Make the course feel credible for a professional brand
• Keep the learner oriented in a realistic CRM workflow
• Reduce unnecessary front-loaded explanation

That’s the real takeaway from this build. You don’t have to choose between practical software training and strong visual design. Start with the task, use the interface as context, and reach for custom blocks only where they make the workflow clearer.

Try this on your next Rise software lesson: replace one generic explanation section with a realistic work artifact, a call transcript, a CRM-style comparison, or another input learners would actually see on the job. The lesson will feel less like a tour and more like practice.