Rolling out new software? If your team is dreading the change or you’re tired of answering the same questions over and over, you’re not alone. Change management is usually a mess—long emails, boring training, and endless confusion. But it doesn’t have to be. This guide is for anyone who wants to make software rollouts less painful and actually help people adapt. We’ll walk through how to use Spekit to keep things simple, clear, and (dare I say) less stressful.
Why Most Change Management Fails (and What Actually Matters)
Let’s be honest: most change management “best practices” are just a checklist that looks good on paper. All-hands meetings, giant PDFs, and one-off trainings don’t actually help people do their jobs better. What people need is:
- Info that’s easy to find, right when they need it
- Clear, no-nonsense answers (not a wall of text)
- A way to ask questions and get help without feeling dumb
Spekit claims to solve this by putting bite-sized help and answers right inside the tools your team actually uses. The trick is using it well—not just dumping your old documentation into a new tool.
Step 1: Get Clear on What Actually Needs Changing
First, don’t just start building out guides and “Splets” (Spekit’s term for micro-knowledge articles) for everything. Focus on:
- The biggest pain points: Where do people usually get stuck?
- Critical changes: What’s truly different in the new software?
- Process changes: What habits or routines need to shift?
Talk to a few frontline users before you do anything. You’ll avoid wasting hours documenting things nobody cares about.
Pro tip: If you don’t know what people are struggling with, just ask. A 10-minute call with a few users beats guessing.
Step 2: Build Micro-Content, Not Manuals
Nobody reads a 30-page training deck. The power of Spekit is in small, specific chunks of content that appear exactly where people need them.
- Write short: Keep each guide to a single concept or step.
- Make it scannable: Use bullets, bold for important stuff, and simple language.
- Skip the fluff: If it isn’t actionable, leave it out.
What works: Embedding quick tips, how-tos, and key definitions right next to buttons or fields in the new software.
What doesn’t: Copy-pasting your old documentation into Spekit. If it was too long and ignored before, it’ll still be ignored.
Example: Instead of a huge “How to Use Salesforce” guide, create a Spekit guide that pops up next to the “Create Opportunity” button with just the info someone needs in that moment.
Step 3: Embed Content Where People Actually Work
This is the big sell for Spekit: you can surface guides, tips, and reminders directly inside the apps your team uses (Salesforce, Slack, Outlook, etc).
- Map out the user journey: Where are people most likely to get confused?
- Attach guides to specific fields, screens, or buttons.
- Use tooltips and in-app banners sparingly: Don’t annoy people with constant popups.
Pitfall to avoid: Overloading every screen with “helpful” tips. If everything is highlighted, nothing stands out.
Pro tip: Ask a few users to do a task while you watch. Note where they hesitate or make mistakes—those are your Spekit hotspots.
Step 4: Keep Communication Short and Ongoing
One-and-done doesn’t work for change management. People need reminders and updates as they settle into the new system.
- Use Spekit’s notifications or Slack integration for short, timely nudges (“Hey, the new process for X starts today”).
- Avoid info dumps. Send small updates, not newsletters.
- Encourage questions and feedback. Make it easy for users to flag what’s unclear.
What works: Two-sentence updates with a link to a Spekit guide.
What doesn’t: Weekly “change management” emails that get ignored or deleted.
Step 5: Measure What’s Actually Being Used
If nobody is viewing your guides, something’s off. Spekit gives you analytics—use them.
- Track which guides get the most views.
- Ask for feedback: Was the content actually helpful?
- Kill or update unused content.
Warning: Don’t get obsessed with vanity metrics. You care about fewer questions, faster onboarding, and fewer mistakes—not just clicks.
Step 6: Train Managers and Superusers First
Change sticks when team leads and go-to people are on board. If you skip this, expect lots of “I didn’t know about this” or “Why are we doing this?” pushback.
- Host a short demo for managers and superusers.
- Show them how to answer questions with Spekit, not email.
- Ask them to flag unclear parts and suggest improvements.
Pitfall to avoid: Assuming everyone will just “find” the new help content. You need visible buy-in from people others trust.
Step 7: Iterate and Prune Ruthlessly
Change management isn’t set-and-forget. Your processes (and people) will shift as folks actually use the new software.
- Regularly review what’s working and what isn’t.
- Remove outdated or redundant guides.
- Update content as you get new questions or find new sticking points.
Pro tip: Schedule a 30-minute review every month. If you’re not deleting something, you’re probably not iterating hard enough.
What to Ignore (and What to Watch Out For)
There’s a lot of hype in the “digital adoption” space. Here’s what you can safely skip:
- Fancy walkthroughs for every workflow. Most people just want one good answer, not a tour.
- Gamification features. Badges and points rarely motivate real adoption.
- Overly polished videos. Fast, rough screen recordings are often better than expensive, outdated tutorials.
Watch out for:
- Over-documenting. More content isn’t better—just more to ignore.
- Relying on Spekit alone. It’s a tool, not a magic bullet. You still need buy-in and a feedback loop.
Wrapping Up: Keep It Simple, Iterate Fast
Rolling out new software is never painless, but if you keep your Spekit content short, relevant, and visible where it matters, you’ll save everyone time and frustration. Focus on the 20% of information people really need. Get feedback early and often, and prune what doesn’t work. Don’t chase perfection—aim for fewer headaches and a team that actually knows what’s changed.
Remember: change management is a process, not a project. Keep it simple, stay curious, and keep trimming the bloat. Your future self (and your team) will thank you.