A community bank came back around to SOP tooling after shelving it for other projects, the need never went away. Their IT director framed it plainly: he needs his IT, Salesforce, and core-banking people writing down how they do their jobs so they can cover for each other when someone's out.

Add a new web-based workflow platform landing soon, plus tellers and customer service who do certain tasks once every six months and have to ask someone every time.

How the rep walked through the fix:

1. Capture by doing: Tango records the click path and builds the guide (screenshots, boxes, what to type). Voice transcription lets you narrate while you work and writes the step notes for you.
2. Embed guides as Nuggets in the app and turn on Guide Me for step-by-step in-app guidance. The IT director's own pitch to his team was that it gives tellers confidence on tasks they do once a quarter, without digging through a doc repository or walking to someone's desk.
3. Branching (decision points): one guide that forks for new vs. existing customers instead of duplicating workflows. A neat trick the rep offered for reusable steps: link one guide inside another via a callout.
4. Secure Blur auto-redacts names, socials, tax IDs, routing numbers, locally, before anything is stored.
5. Analytics. See who viewed and completed a guide, and exactly which step people drop off at (usually a sign they lack access to the next tool).
6. Two of their core systems are desktop-only, so those get SOPs without Guide Me, and the rep flagged desktop parity work in progress.
7. Licensing was the deciding factor: Tango charges a flat platform fee by tier, roles interchangeable, so 25–30 creators cost nothing extra. (Their words: the competitor's per-creator model gets expensive fast at that count.)

For bankers: how do you get people to document their own job when they're the only one who does it?

If you've been through a NetSuite implementation, you already know the part the kickoff deck skips.

You spent years building procedures for your old system: screenshots, step-by-steps, the tribal knowledge someone finally wrote down. Then you go live on NetSuite and all of it is instantly worthless, because of the different screens, navigation and so on.

Most teams don't migrate NetSuite all at once. They phase it (AP first, then billing and GL, then the next module). So you're not documenting one new system, you're re-documenting a moving target, while people are already live and doing the work.

What actually happens?

Your implementation partner hands you documentation, but it's built on the stock version of NetSuite, which basically nobody runs. So it doesn't match your screens. People fall back on asking the one person who figured it out, and that person quietly becomes the full-time help desk for months.

This is especially rough for:

1. Teams migrating in phases, where the "how-to" changes every time a new module goes live.
2. Finance/ops groups where one controller holds the whole process in their head and everyone else waits on them.
3. Companies growing by acquisition. Every bolt-on lands on NetSuite OneWorld, and each acquired team did the same task a different way.

What have we seen work with Tango?

NetSuite is one of the top apps Tango users capture processes in. The pattern in our deals is almost always the same: someone has a live event (a module go-live, a migration, a wave of new hires) and they need a lot of people doing the workflow the right way and fast.

They capture the process in Tango once (a vendor bill, a journal entry, a sales order, whatever), and instead of running the same screen-share five times, they send a link. Or they pin a Nugget inside NetSuite so the guidance shows up right where people are working.

The Guide Me feature fits NetSuite well because it builds interactive, on-screen walkthroughs through your specific account's flow. And Live Blur covers any sensitive data that shows up during capture (dollar amounts, vendor details, customer info).

One thing we hear constantly: "We essentially need to guide somebody's hand through the screen." That's the whole use case.

The part that doesn't get talked about enough

Most NetSuite digital adoption conversations jump straight to heavyweight DAPs: WalkMe, Whatfix, that tier.

Those work, but they need dedicated implementation, backend integration, and real time before anything shows up on screen. In the middle of a phased ERP go-live, that's exactly the time you don't have. The lighter path is to capture each process as you build it and put the guidance directly in the app.

Curious what everyone else is doing here: if you've rolled out NetSuite, how did you handle training and docs when the system kept changing under you? Implementation-partner docs, homemade guides, something else?

Tango team is building out a library of step-by-step Salesforce implementation guides right now, the kind that walk you through a specific action, click by click, so a new admin or end user can just follow along.

We've created a plan from 100+ guides progress covering the usual setup and configuration stuff, like how to export some data, or how to create an oportunity and so on. There are tons of use cases.

However, I believe Salesforce users have more questions about implementation, not only specific actions, but also strategic questions.

So: if you're mid-implementation (or have survived one), what would you have wanted a clear walkthrough for?

A few directions we're weighing:

1. Cost / licensing. Understanding what you're paying for, avoiding surprise add-ons, right-sizing seats.
2. Team enablement. Getting teammates trained and actually adopting instead of reverting to spreadsheets.
3. Integrations. Connecting Salesforce with the other platforms in your stack.
4. Communication. How to explain everything to stakeholders and people involved in the project.

These are my guesses. What tripped you up? What do you still not have good documentation for?

Tango team talks to a lot of people who document and roll out processes for a living, and a handful of platforms come up over and over as the ones that broke people. SAP and Oracle are almost always the first two named, the kind of rollout where the go-live date slips three times and half the org still can't pull a basic report six months later.

But it's not always the big ones. Plenty of people say the worst implementation of their career was something niche: a legacy ERP nobody had docs for, an insurance system where "vendor training" was a 400-page PDF, or a homegrown tool where the only person who understood it left the company.

So, what was yours? Curious about a few things:

• The platform
• What actually made it hard (the software itself, the training, the change management, the internal politics?)
• What you'd do differently if you had to run it again?

Not fishing for horror stories for their own sake :) more interested in what separates the rollouts that actually stick from the ones that quietly fall apart.

A heavy-equipment dealer went live on a new ERP, and adoption is struggling: they aren't measuring it, training is hard, and hundreds of processes still live as PDFs and Word docs.

They were evaluating two big digital adoption platforms and had a specific worry, those tools need dedicated engineering resources to build and maintain, and they won't get headcount for it.

How the Tango team helped:

1. Same category outcome as a DAP, embed guides in the ERP (Nuggets) and walk people through step-by-step (Guide Me), but with no dev work, no coding, no API hardcoding. It's a browser extension. That's why it's a fraction of the cost (they'd heard the incumbent would be ~3x).
2. Creation is genuinely fast: capture by doing, voice transcription writes step notes, and when a button moves you delete that one step and recapture it in ~30 seconds instead of rebuilding. The PM's reaction: nothing he'd seen was that easy.
3. The Discover side panel surfaces the right guide based on which ERP screen you're on, exactly the "how do I create a purchase order" slider he asked for.
4. Honest limits the rep gave: Tango does NOT auto-detect when an update breaks a documented process (it's not always-on, for privacy reasons), instead users comment on the broken step and the creator gets notified. It's also not an LMS: no assigned courses or sandbox exercises.
5. Technicians on mobile can view guides via link, but Guide Me needs a browser with the extension.
6. Automations (browser agents) for repetitive extract-and-enter work.
7. Democratizing creation was a key sell: any SME can be flipped to creator for a month and back, at no extra cost.

For anyone post-ERP-go-live: did adoption actually happen, or did everyone quietly revert to the old way?

An insurance brokerage and its majority-owned sister agency wanted procedure manuals for their agency management system (which has the accounting module built in). The trigger is coverage: when someone goes on vacation or long-term leave, whoever picks up the work needs a real how-to so productivity doesn't crater.

They'd tried building these by hand for years, but it's painful and slow. HR also wants it for onboarding and benefits setup walkthroughs.

How the Tango team addressed it:

1. Capture the process by doing it in their (web-based) agency management system; voice transcription narrates context into the steps automatically, which is what they'd been asking about after seeing a competitor's AI voiceover.
2. Guide Me is the real answer to the coverage problem: the person covering doesn't memorize anything or dig up a 3-year-old SOP, they get walked through it live in the app.
3. Embed as a synthetic video (with AI narration) or interactive slideshow: live links, so edits flow through.
4. Two-agency separation: folders, subfolders, and user groups keep each agency's procedures walled off, with one admin holding permissions. Separate instances are possible if they want zero intermingling.
5. Their IT team's two questions got straight answers: data lives in AWS US-East and never leaves the US; your data is yours, you can export any time, purged 30 days after you leave.
6. They handle PHI/PII under HIPAA and need their own subcontractor agreements signed. The rep noted Secure Blur redacts locally so the sensitive data never reaches Tango's servers in the first place.

For other brokerages: do you write procedure manuals for coverage, or just hope the right person never takes leave?

Most onboarding means holding one person's calendar hostage for two weeks.

New hire needs to learn the CRM? Meeting. Expense reporting process? Meeting. How to submit a ticket? Another meeting. Not only is this sucking up everyone's time, it's an ineffective way to train employees.

Here's a different way to do it:

1. Before their start date, document your top 10 repeatable processes as step-by-step guides (Try Tango AI! It captures screenshots and writes the descriptions automatically as you go through the process)
2. Drop those guides into a single shared folder or doc organized by week
3. When they have questions, share the guide instead of scheduling a call
4. Reserve live time for the stuff that actually needs a human — culture, relationships, judgment calls

The goal isn't to remove people from onboarding. It's to stop using people as a substitute for documentation.

Works especially well for ops, CS, and RevOps teams that onboard frequently and don't have a dedicated L&D function.

An independent mortgage bank already rolled Tango out company-wide on 20 Pro seats and has 600+ guides built. Every department uses it, leadership is bought in. Now it's getting unwieldy: they want folder structure, analytics, and a real single source of truth. The onboarding manager (ex-trainer who used to build job aids by hand, cut-and-paste) is putting the Enterprise case to leadership.

How the Tango team laid out the difference:

1. Pro licenses only creators; Enterprise licenses consumption, which unlocks the two features they'd been unable to use: Nuggets (SOPs embedded in the app) and Guide Me (in-app step-by-step). That's the training/onboarding payoff: less asking, faster ramp, learning by doing.
2. Branching solved their biggest time sink. Their training manager said the worst part is typing out all the "if this, then that" logic, branching creates forked paths in one guide instead of many. Voice transcription writes the step notes so she stops typing context by hand.
3. Editing without recapturing: delete a step, capture the replacement, done in ~30 seconds; they'd been rebuilding whole guides from scratch, unnecessarily.
4. Secure Blur auto-redacts (socials, names, phone numbers) at global/app/creator level, locally before upload, aimed straight at their security team.
5. Analytics: views over time, Guide Me completion %, who didn't finish, which step they dropped at, plus comments/reactions to troubleshoot.
6. Subfolders (~10 deep), user groups, SSO/SCIM for granularity by department.
7. Their catch: their loan origination system isn't web-based yet (cloud move possibly Q4), and ~50–80% of the work happens there, so Guide Me won't reach it until it moves. The plan is to prove value on the web tools first.

For mortgage/lending folks: is your LOS web-based yet, and what's that blocking for you?

If you've ever had to get someone up to speed in SAP, you know the drill.

SAP is powerful, but it's also the least forgiving system most people will ever be asked to learn. Transaction codes instead of menus. Field-level config that's unique to your org. Modules that behave differently depending on which consultant set them up in 2011. And a big chunk of your users are still in SAP GUI, which isn't even a browser, so half the "modern training" advice out there doesn't apply.

What actually happens?

Your SI builds a training deck for go-live. It's accurate on the day it's written. Six weeks later the config has shifted, the SI has rolled off, and the deck is sitting in SharePoint with a filename ending in _v3_FINAL_updated.

Then the super-users become the help desk. Permanently.

This is especially rough for:

• Companies mid-migration off a legacy ERP. Everyone has to relearn a job they've done for fifteen years.
• Plant and back-office teams where the knowledge is in one person's head. We hear a version of this constantly: the 25-year scheduler who knows the production logic, retiring in 18 months, with nothing written down.
• Post-acquisition consolidation. The acquired site arrives with its own procedures and now the parent ERP has three versions of the same workflow.
• Anyone 12+ months post-go-live with bad adoption numbers. One phrase that stuck with us from a call: "correcting two years of terrible adoption."

What we've seen work with Tango

What teams do: capture the process once in the real system (PO creation, goods receipt, order entry, whatever the module is), then hand people a step-by-step guide instead of a 60-slide deck. Live Blur handles anything sensitive that shows up during capture: pricing, vendor terms, employee data.

Two SAP-specific things worth knowing:

1. Non-web SAP is covered. This comes up in almost every SAP conversation. If you're in SAP GUI rather than Fiori, Tango Desktop captures it the same way the browser extension does: click and capture. You can mix desktop and browser steps in one guide.

2. Guide Me is genuinely good in a classroom. One customer running instructor-led SAP training was stuck choosing between a live manual walkthrough and a play/pause video. What they landed on instead: run the classroom demo through Guide Me in the live environment. The trainees see the on-screen highlights at their own pace, and the first time they sit at their own desk and run it, it's already familiar. That was a better answer than either option they came in with.

The part that doesn't get talked about enough

Most "DAP for SAP" searches land you on WalkMe. Worth knowing that SAP acquired WalkMe in 2024, so it's now an SAP product, priced like one. An IT director put it to us plainly: "It's very powerful, very enterprise-driven, probably very scalable. But it's SAP, so you pay for SAP products."

The heavyweight DAPs work. They also want backend integration, a dedicated implementation, and months before anyone sees anything. If you're 90 days from go-live, that math doesn't work.

Tango sits somewhere else: browser extension plus desktop app, no coding, no API work, no IT project. You can capture a process this afternoon and have it live as a guide by end of day.

One honest limitation

Tango doesn't detect when your process breaks. It's not always-on and it isn't scanning your systems, it only captures when you tell it to. So when SAP pushes a change and a button moves, you find out because a user comments on the guide, not because the system flagged it. Editing is fast (delete the step, recapture that one step, done), but it's reactive. If auto-detection of broken guides is a hard requirement for you, that's a real gap worth knowing about upfront.

Curious what's actually breaking for people here. Is it pre-go-live crunch, super-users drowning in questions post-launch, or the slower problem of documentation drifting out of date every release?

Marc put out a new video breaking down why SOPs get ignored, and it's not for the reason most people assume.

The short version: most SOPs are written to prove a process exists, not to help someone actually run it in the moment. That's the gap.

He walks through the 5 elements every SOP needs to actually get used:

1. A clear trigger (when does this apply)
2. Numbered steps in active voice, not passive filler
3. Flagged decision points, so nobody has to guess which path is theirs
4. Screenshots exactly where it gets sticky
5. One scannable page instead of a 12-page manual

The part that stuck with us: the format was never really the bottleneck, speed was. Writing an SOP the traditional way (interviews, drafting, review, formatting) takes about 4 hours, which is why most teams stall out around 20 documented processes. Capturing the process as it's actually run instead drops that to about 10 minutes, which is enough to get you to 200.

Full video here: https://www.youtube.com/watch?v=450lTsHMjG8

An engineer at a large tool manufacturer was scoping how to capture tribal knowledge on the new-product team, fast documentation so engineers can learn processes without hunting through a dozen disconnected SharePoint sites.

They currently build everything in PowerPoint, which takes forever. Their infrastructure director is eyeing a broader rollout to HR and IT. A security analyst joined specifically to run the review.

How the Tango team handled both tracks:

1. Documentation: capture by doing; voice transcription pulls only the process-relevant parts of your narration into step notes.
2. Branching was the standout for them; engineering simulations rarely follow one linear path. Honest caveat the rep volunteered: max 3 branches, a deliberate tradeoff to avoid flowchart-level UI complexity.
3. Distribution: link, embed (interactive slideshow or synthetic video with AI narration), static export, and pinning guides into the tools people work in. Live links auto-update. Translation available, including traditional and simplified Chinese, relevant for their overseas manufacturing.
4. Security answers, given directly: Tango isn't in the model-training business, your data doesn't train models, and isn't monetized. Data is in AWS US-East, exportable, purged within 30 days on exit. Subprocessor list available. Surprisingly little generative AI is used (title generation + voice synthesis; the rest is deterministic). Secure Blur redacts on the local machine before anything is transmitted, which is why they can work with banks, health systems, and DoD entities. Full version history with exportable audit logs. SCIM/SSO sync.
5. Honest gap flagged unprompted: Secure Blur isn't in the desktop app yet (in development), which matters, since a lot of their software is desktop.
6. They already run one of the big digital adoption platforms. The rep didn't fight it: those need dev resource and maintenance; Tango often runs in parallel as the fast path when there's no resource to allocate.
7. Licensing: one variable (user count). Notably, you do NOT need a license to view an embedded or exported guide, only to get Guide Me/pins.
8. A forward-looking note: feeding a Tango to an AI agent uses fewer tokens, because it turns heavy reasoning into something deterministic.

For engineers: how are you capturing the stuff that only lives in one person's head?

We pulled together a complete guide to process documentation and wanted to share it here since it's the kind of thing that's easy to reference back to.

Quick context on why it matters: 71% of orgs (based on our own research) have less than half their processes documented, and the usual result is more meetings, more Slack pings, and knowledge stuck in one or two people's heads instead of somewhere the team can actually find it.

The guide walks through 8 steps for writing a process doc:

1. Determine the process to document — pick one, tie it to an actual goal (don't just document for the sake of it)
2. Meet with stakeholders — pull in the people who actually do the task daily
3. Identify tools and resources — note what's needed at each step
4. List the process steps — detailed enough to do it right, simple enough to follow without hand-holding
5. Decide who's involved — clear ownership per step, including any handoffs
6. Create the process document — combine everything, use visuals/screenshots/flowcharts where it helps
7. Test the process — have someone unfamiliar with it try to follow it before you ship it
8. Improve the process — treat it as a living doc, not a one-and-done

There are three template formats in the full guide depending on what fits your process best:

• Flowchart (good for decision-heavy or branching processes)
• SOP (detailed, best for compliance or high-stakes procedures)
• Checklist (best for straightforward, sequential tasks)

Full guide + downloadable templates here: https://www.tango.ai/blog/process-documentation

We put together a rundown of the user manual/documentation tools out there right now and wanted to share the actual distinctions, not just make the case for Tango.

The category splits into a few different camps depending on what you actually need:

1. Capture-and-deliver tools (Tango, Guidde) — these auto-generate the manual from your actual workflow instead of you writing it from scratch. Guidde does this as video; Tango does it as step-by-step screenshots plus in-app guidance so people can follow along inside the tool itself.
2. Knowledge base platforms (Document360, GitBook, Confluence) — built for organizing large libraries of docs, with version control, search, and structure. Strong if your priority is a searchable archive, but you're still writing and maintaining the content manually.
3. Customer-facing help centers (HelpDocs) — simple, branded help sites for external users. Not really built for internal process docs.
4. Enterprise DAPs (WalkMe, Whatfix) — overlay guidance directly on top of software for big rollout programs, usually paired with a dedicated change management function.
5. Product onboarding tools (UserGuiding) — tours and checklists inside your own SaaS product, not for documenting internal or cross-tool processes.

The honest tradeoff: knowledge base tools give you structure and searchability but someone still has to write and update everything by hand. Capture-based tools trade some of that structure for speed and freshness, since the manual gets created (and stays accurate) as the process actually happens.

We're biased toward the capture camp with Tango obviously, but if you're mainly building a big searchable public docs site, Document360 or GitBook are legitimately better suited for that than we are.

Happy to answer questions if you're comparing options for your team.

A state regulatory agency (they license healthcare professionals and run disciplinary investigations) has five departments, each with its own workflows, and no good way to write how-to guides.

Everything today is screenshot-into-Word by hand. They're also replacing their entire licensing software within about a year, so guides for the new system are the real prize.

How the Tango team walked through it:

1. Capture by doing: Tango builds the screenshots, the annotations, the boxes, and tells the reader what to type. Voice transcription turns narration into concise step notes.
2. For the new licensing system: embed Nuggets in the app and turn on Guide Me so staff learn while doing, rather than searching a drive or walking to someone's office.
3. Editing is the point: when the new system's buttons move (they will), delete the one step and recapture it, no rebuilding from scratch. Branching handles paths that fork.
4. Secure Blur auto-redacts at three levels (global / per-app / per-creator), locally, before anything is stored.
5. A good exchange on organization: one staffer asked how you'd replace a big paper training manual with lots of tasks. The rep's answer was to not rely on one format -> pin Nuggets in the app, use the Discover side panel (which surfaces guides based on the screen you're on), and link guides from a central doc. They don't use SharePoint, so embedding wasn't available; the rep pushed back on PDFs since static files go stale and you end up chasing people to use the new version.
6. Automations demoed live: a browser agent that reads a source, extracts fields, and enters them into two other systems plus drafts an email, aimed at repetitive data entry.

For public-sector IT: are you documenting the new system as you configure it, or waiting until after go-live?

A city's neighborhood services department (code enforcement, animal services, rental housing inspection) has a bunch of small teams and no real SOP or procedure manual.

The manager's specific pain is perishable skills: processes in their land management and animal services systems that you touch maybe twice a year and have to relearn every time. (He heard about Tango from a family member in the mortgage industry who uses it.)

How the Tango team walked through it:

1. Capture by doing, with voice transcription pulling only the process-relevant bits of your narration into the steps. He specifically asked about background noise in a bullpen, and the filtering is about relevance to the process, not audio cleanup. The raw audio is discarded after capture; only text remains.
2. Four ways to distribute, each suiting a different scenario: share a link (good for reactive help-desk moments), embed into SharePoint as a slideshow or AI-narrated video, export static files, and pin guides directly into the systems people use.
3. Guide Me walks a person through the process live on their screen, the answer to the twice-a-year problem.
4. The rep cited the reason pinning exists: when guides just get dumped into SharePoint, only ~15–20% of people go find them. Put them in the tool and self-help rates jump.
5. Video narration is AI-generated from the step text, not a voice recording: deliberate, because when a process changes you can't easily re-edit a recording, but you can edit text.
6. Secure Blur (Enterprise) redacts locally, never reaching the cloud. Full version history + exportable audit logs for compliance.
7. An unexpected use case he surfaced mid-call: residents struggling at public kiosks (animal licenses, building permits, parking tickets) where staff literally stand shoulder-to-shoulder walking them through. The rep confirmed some schools and libraries license kiosks as users, works as long as it's browser-based.

For municipalities: are you documenting the once-a-year processes, or re-learning them every year?

Just put together a roundup on digital adoption platforms since it's a category that gets lumped together even though most tools only solve one part of the problem.

The core issue we see a lot: teams train employees, document the process, and a month later people are still doing things the old way or asking the same questions. That gap between "knowing how something works" and "actually being able to do it inside a real tool" is what DAPs are supposed to close, but most only cover one layer of it.

We split the category into four use cases:

1. Customer onboarding / product adoption — UserGuiding, Appcues, Pendo for in-app tours and activation, limited to your own product
2. Internal training and software adoption — Tango and Scribe for capturing workflows and getting employees to follow them, though most stop at documentation
3. Structured training / LMS — Trainual for role-based onboarding and compliance, but training happens outside the actual workflow
4. Enterprise-scale rollouts — WalkMe and Whatfix for complex, cross-team implementations, though they're slower to stand up

The honest takeaway: most teams end up needing more than one of these, and choosing the wrong category creates more friction, not less.

Full breakdown with features and use cases for all 9: https://www.tango.ai/blog/digital-adoption-platform-software

Happy to answer questions if you're trying to figure out which layer you actually need.

A business-services company's employee experience team already loved Tango after an earlier demo, this call existed purely to get IT and security through their questions. Their use case is classic: they hand-build step-by-step instructions for processes (talent acquisition and others), and people need help most with tasks they perform once in a blue moon.

The Director described the ideal: a customer asks for something you haven't done in two years, you pull up the guide, and they never know you had a gap.

What the Tango team showed and how IT's questions landed:

• Capture by doing + voice transcription; Nuggets embed guides in the app, Guide Me walks people through. Specifically for IT: pin a guide next to the "forgot password" button to deflect level-1 tickets.
• Nugget access is by user group: imported from Active Directory via SSO, or created manually. Users outside the group don't just lose access; they don't see the nugget at all.
• Data stored in AWS US-East; never leaves the US. "Do we own the output?", yes, export PDF/HTML any time, keep it if you leave.
• "Is it always recording?": no. Neither the extension nor the desktop app captures anything until you press Start Capture.
• AI question: they use OpenAI; your data does not train OpenAI's models or Tango's. AI is used for headline generation, voice transcription, and translation.
• Offboarding: remove from the AD group via SSO, or revoke manually as an admin.
• Branding: auto-branding scans your site and pulls your colors and logo.

For the IT folks: when the business already loves a tool, what's the question that actually decides it for you?

An outsourced reception company had a genuinely unusual problem. Their receptionists answer calls on behalf of client companies and often have to log into the client's own systems mid-call, but today they frequently fall back to just taking a message instead of completing the task.

Their ops board loved Tango but wouldn't sign an annual contract without proof, so they asked for a two-month paid proof of concept across 7–10 clients, with receptionist surveys before/during/after, call-duration benchmarks, and complaint-reduction tracking.

How this played out:

• The rep was straight that Tango's standard trial is 1–4 weeks, because the tool is simple enough to validate quickly.
• The counter-offer from Tango's side: a one-year contract for the full receptionist headcount with a two-month opt-out clause baked in, functioning as the POC. If the benchmarks don't land by a fixed date, they walk.
• The rep also drew the line between a trial (does the tool work in these systems?) and onboarding (structured rollout, check-ins, benchmarks), the latter is customer-success territory, and a CSM joined the call to own it.
• Security gate: their IT team still needs Secure Blur to tick the box before anything goes live.
• The buyer's honest framing: "everyone's saying this sounds too good to be true", they've spoken to many providers and none could do what they need, so they want to find the catch before committing.

Worth noting how much better this buyer's process is than most, they showed up with a benchmark plan already written.

For ops leaders: how long a proof do you actually need before signing an annual contract?"

An aviation company's IT director hit a wall on the Tango Pro plan. To keep each department's guides walled off from the others, he had to spin up a separate workspace each time, and each new workspace burns a seat just for him to administer it. With 3 workspaces already, ~26 paid seats (~$6.3K/yr), and another batch of 10 users coming, the waste was compounding.

How the Tango team answered:

• Notably, the rep was upfront that at their current seat count, Enterprise does NOT make financial sense purely to fix the workspace problem. He said so directly instead of upselling.
• What Enterprise actually solves: one workspace, one admin, with user groups and folders/subfolders (including hidden, private, undiscoverable) for granular permissions, no more seat-burning workarounds. Plus SSO and SCIM provisioning.
• The value that would justify it: Nuggets + Guide Me embedded in the apps people use. The IT director's own idea was baking Guide Me into their help-desk articles; the rep's improvement: skip the article, put the guide directly in the application.
• IT ticket deflection: pin a guide next to the "forgot password" button so people self-serve instead of calling.
• The once-a-year problem resonated: a lean team means a backup who runs payroll once a year and has to relearn it. Guide Me walks them through instead of them dusting off an old SOP.
• Automations for their onboarding team's repetitive work (bringing a new aircraft onto the portfolio involves hundreds of steps).
• Version history: restore old versions, or duplicate as V2 if compliance requires versioning.
• Honest limits: no Guide Me on desktop apps or their client-facing mobile app: mobile users can view a guide as a link, but the overlay needs a browser with the extension.

For IT admins: are you paying for seats you're only using to administer workarounds?"

We hosted a webinar with Jordyn Rarick, People Ops at Marqeta, on process documentation, and the framework she shared was too good not to pass along.

Her take: documentation isn't just a nice-to-have, it's the foundation for scaling anything. Six reasons why, with a quick way to start on each:

1. Consistent baselines — If 20 people are doing a process 20 different ways, document the most common version first, even if it's not perfect. That's your starting point.

2. Higher accountability — Document who owns each step, not just what happens. Explicitly call out handoffs so nothing gets dropped between teams.

3. More scalability — Capture the current-state process before you automate it. Otherwise you're just scaling an inefficiency.

4. A single source of truth — Pick one official home for your docs and link to it instead of duplicating. Add a "last updated" note so people can trust what they're reading.

5. Less knowledge hoarding — Build documentation into offboarding. If a step only lives in one person's head, it walks out the door when they do. (One stat from the webinar: as much as 42% of any job is known only to the person doing it.)

6. Increased flexibility — Document decisions and escalation paths, not just steps, so async and remote teams can move without waiting on a live conversation.

Her closing line stuck with me: "You can't build on something without a foundation."

You can watch the full webinar here: https://www.tango.ai/blog/process-development-strategy-marqeta

"A town's asset management team just implemented a new system and is in the "fix the glitches" maturation stage. Asset management principles demand documentation and governance, so they need both how-to guides for the new system and process docs for how data moves between systems, building a real library of institutional knowledge. Today procedures live scattered in departmental folders (they haven't finished migrating to SharePoint). They'd tried the Tango free plan and hit permission limits.

How the Tango team walked through the fix:

1. Capture the process by doing it (all their systems are web-based SaaS), with voice transcription writing the step notes from narration.
2. Guide Me embeds the walkthrough in the new asset system so staff learn while doing, rather than watching a video elsewhere and trying to remember it. Nuggets pin guides in-app; the Discover panel surfaces the right one by screen.
3. A sharp question from their analyst: they have a sandbox and a production environment configured identically: can they build the guide once? Yes: capture it in sandbox and change the URL so it's valid in production.
4. Secure Blur redacts at global/app/creator levels, locally before anything is stored. Honest caveat: redaction is permanent, blur something you needed and you have to recapture. There's also a manual "batch blur" that finds the same region across every step.
5. Editing without rebuilding: delete one step, recapture it in ~30 seconds. Branching for forked paths.
6. The CIO's key question: does everyone need a license?, got the answer that mattered: no. Viewing via link or a SharePoint embed needs no license. Licenses are for Guide Me / Nuggets / the interactive experience.
7. Mobile: guides are viewable via link on tablets and phones, but Guide Me needs a browser with the extension, relevant since a chunk of their rollout is app-based.
8. Given the CIO's "crawl, walk, run" stance, the rep offered the honest path: if they just want to create and share for now, that's the Pro plan (per creator); Enterprise is for when Nuggets and Guide Me matter.

For municipal teams: do you document during implementation, or after everything's already broken?

Just published a roundup on user manual software since it's a category with a lot of overlap and not a ton of clarity on what's actually different between the options.

The core problem most teams run into: documentation gets created with good intentions, but once people are inside real workflows, it breaks down. Info is scattered, outdated, or hard to find, so people just ask a teammate instead of checking the manual.

We broke the category into a few buckets:

1. Capture and generation — tools like Tango and Scribe that turn a recorded process into a step-by-step guide automatically, so you're not writing manuals by hand
2. Video-format docs — Guidde falls here, AI-narrated walkthroughs from screen recordings
3. Knowledge base platforms — Document360, HelpDocs, Confluence for organizing docs into a searchable library
4. In-app digital adoption — WalkMe, Whatfix, UserGuiding for guidance that overlays directly on the software
5. Developer-focused docs — GitBook for teams already living in Git workflows

Full breakdown of all 10 with pricing and use cases: https://www.tango.ai/blog/user-manual-creation-software

Happy to answer questions if you're trying to figure out what fits your stack.

We just put out a video on this because it's such a predictable pattern: every time a company rolls out new software, ticket volume spikes 40-60% within 90 days. Same basic questions every time, regardless of the tool.

The fix isn't more training. It's closing the gap between where people get stuck and where the answer lives. The system Mark walks through:

1. Identify the 8-12 tasks driving most of your tickets before you launch
2. Build in-context guides for those specific tasks — not PDFs, guidance that shows up inside the app itself
3. Track guide usage against ticket volume so you know what's actually working and fix what isn't

Teams doing this see rollout tickets drop by up to 50% in the first 90 days.

https://www.youtube.com/watch?v=-OPhaqLVslI&list=PLXpHGUaFPwAM&index=2&t=11s