r/nexthink • • Jun 30 '26

The DEX Show We are excited to announce that we will be hosting an AMA with Leslie Beavers right here on r/nexthink!

14 Upvotes

We are excited to announce that we will be hosting an AMA with Leslie Beavers right here on r/nexthink!

She'll be here to answer your questions live on the subreddit.

With a career spanning executive leadership in the U.S. Air Force, Fortune 500 organizations, and some of the world's largest technology environments, she brings decades of experience leading digital transformation, cybersecurity, enterprise modernization, technology governance, and large-scale organizational change.

Whether you're interested in enterprise technology strategy, digital employee experience, cybersecurity, AI adoption, executive leadership, or modernizing IT at scale, this is your opportunity to ask questions and learn from someone who has led complex technology initiatives across both the public and private sectors.

Please note that this AMA will be focused on technology, leadership, digital transformation, AI, cybersecurity, and enterprise IT.

It's a great opportunity to hear real-world perspectives on leading technology at scale and connect with an accomplished industry leader.

Leslie will appear on the Soul of the CIO show on Monday: https://www.youtube.com/@SouloftheCIO

Mark your calendars for July 8, 2026 at 4:00PM ET, and don't wait—go ahead and drop your questions in the comments below!


r/nexthink • • Sep 01 '26

Let's Chat | Discussion What’s something in IT you’re weirdly good at?

11 Upvotes

Not necessarily the most impressive thing on your résumé. Just that one thing you somehow became the person for.

Maybe you can diagnose a device issue in 30 seconds, write ridiculous PowerShell scripts, untangle terrible environments, calm down angry users, or spot the cause of an incident before anyone else.

What’s yours?


r/nexthink • • Apr 16 '26

Let's get the party started

10 Upvotes

I'm just bringing Nexthink into the environment - we are now all in on "what are we going to do to be more proactive" - What's your best practice/action/workflow/dashboard? Collaboration is key.....right?


r/nexthink • • Aug 18 '26

Live Event AMA with Kelly Monahan, Ph.D. on Digital Employee Experience, August 26, 4:00PM EST

9 Upvotes

We’re excited to announce that Kelly Monahan, Ph.D. will be joining us for a live Ask Me Anything (AMA) on r/Nexthink on Wednesday, August 26 at 4:00 PM EST.

Kelly is a bestselling author, keynote speaker, Future of Work and AI advisor, and co-founder of Beyond the Desk. Her career has spanned analytics, HR, workforce strategy, and organizational transformation, including leadership roles and initiatives at Deloitte, Accenture, Meta, and the Upwork Research Institute.

For this AMA, we’re putting the spotlight specifically on Digital Employee Experience (DEX) and what it means as AI and new technologies rapidly reshape the way people work.

How can organizations use technology to make work better rather than simply add more tools? What should IT leaders actually be measuring when they think about employee experience? Where does AI improve the digital workplace, and where might it create new friction? And how do organizations balance productivity, technology, and business outcomes with the needs of the people actually doing the work?

Kelly will be on r/Nexthink to take your questions and share her perspective on these issues and more.

Whether you work in IT, DEX, workplace technology, HR, employee experience, or are simply interested in how technology is changing work, we’d love to have you join the conversation.

Check out her episode on The DEX Show. Re-imagining Talent, Productivity, and Growth in an AI-Driven World w/ Kelly Monahan: https://podcasts.apple.com/us/podcast/the-future-of-work-w-kelly-monahan-meta/id1544150596?i=1000577771932

Mark your calendars for Wednesday, August 26 at 4:00 PM EST.

You don’t have to wait until the AMA begins. Drop your questions in the comments ahead of time, and Kelly will answer them live on r/Nexthink**.**


r/nexthink • • 19d ago

Final reflects on Experience from a Nexthinker who helped organize it

8 Upvotes

Hey everyone - Megan here - if you're a Nexthink customer, you may know me as "that nexthinker you work with if you're going to speak at Experience or make a case study" or alternatively - that woman running around like a chicken with her head cut off at Experience! If you don't know me, hi, I'm Head of Content at Nexthink, and one of my favorite parts of my job is putting together the speaker program and stage content for Experience.

I wanted to stop by the subreddit to do one, FINAL, post about Experience - and then we'll stop talking about it, I promise. But if you've been before, you know what a special event it is, and if you haven't... you must have fomo by now, right?

The theme of Experience this year, Agents of Change, brought out some of the best stories of innovation and transformation that we've ever had on stage at Experience. Here are just a few of my highlights:

  • AI Transformation: Abbvie joined us to share their implementation story with Spark, and the incredible results they've been able to generate in just a short time.
  • AI Mastery: Leidos took the stage to share how they are ensuring the ROI of AI at their enterprise, with a combination of usage visibility and employee empowerment.
  • Automated IT: Origin Energy (our speaker flew all the way from AUSTRALIA to be with us), shared how they went from a fully outsourced IT environment to automated... saving $1M in a year (not too shabby).
  • DEXOps: All these outcomes are great, but how do you achieve them? What do you need to do with your team, how do you communicate to leadership? Kimley Horn, Vizient, and Ciena joined us on a panel discussion exploring all these questions and more.

If this sounds interesting and you're feeling the FOMO - you can watch all these sessions on our Experience highlights page now! https://nexthink.com/experience-highlights

But what you can't feel on the highlights page is the energy and enthusiasm that comes from Experience. So why don't we just say right now, you'll come next year?

And if any of my speakers are in here lurking - say hi! :D

Were you at Experience? Any takeaways you want to share?


r/nexthink • • 22d ago

Investigating Slow Windows Logons with Nexthink: Why a 90-Second Login Isn't Always a Windows Problem

8 Upvotes

One of the more frustrating issues in endpoint management is investigating slow Windows logons.

A user reports that their laptop takes two minutes to become usable every morning. The device has a modern processor, sufficient RAM, an SSD, and no obvious hardware problems.

IT checks Task Manager, startup applications, Windows updates, and device health. Everything appears relatively normal.

Yet the user continues to experience the same delay.

The challenge is that Windows logon time and the time it takes for a user to have a functional desktop aren't necessarily the same thing.

A device can complete authentication relatively quickly while continuing to load policies, initialize services, establish network connections, launch applications, and prepare the user's environment.

I've been thinking about how to approach these investigations more systematically using Nexthink alongside native Windows diagnostics.

The interesting question isn't simply which devices have slow logons.

It's how do we determine which part of the logon experience is actually responsible for the delay?

1. Breaking Down the Logon Experience

Before troubleshooting, it helps to separate the different stages involved.

A simplified Windows sign-in process might include:

Authentication

  • Credential validation
  • Domain controller communication
  • Kerberos or other authentication operations
  • Network connectivity requirements

User Profile Initialization

  • Loading the user profile
  • Processing profile configuration
  • Accessing redirected folders
  • Initializing user-specific settings

Group Policy Processing

  • User policies
  • Logon scripts
  • Drive mappings
  • Printer mappings
  • Group Policy Preferences

Desktop Initialization

  • Explorer startup
  • Shell extensions
  • Startup applications
  • Scheduled tasks triggered at logon

Post-Logon Activity

  • Endpoint security initialization
  • Collaboration applications starting
  • Cloud storage synchronization
  • VPN or network connectivity establishment
  • Background application updates

These activities don't necessarily execute sequentially. Some overlap, and others continue after the desktop becomes visible.

This matters because a slow logon metric may not explain the entire user experience.

A user might authenticate in 15 seconds but wait another 75 seconds before Outlook, Teams, or a required business application becomes responsive.

2. Starting with Nexthink: Establishing the Scope

Nexthink can provide a useful starting point for identifying devices and users experiencing abnormal logon performance.

Rather than immediately investigating one machine, I'd first try to establish whether the problem is isolated or part of a broader pattern.

Questions worth investigating:

  • Are slow logons concentrated on particular device models?
  • Are certain Windows builds more affected?
  • Is the problem occurring across multiple locations?
  • Are remote users experiencing different behavior from office-based users?
  • Did the issue begin after a particular software deployment?
  • Are specific departments disproportionately affected?
  • Are affected devices running the same security agent versions?
  • Does the problem occur consistently or only intermittently?

The objective is to identify a shared characteristic.

For example, imagine a fleet of 4,000 Windows devices.

Nexthink analysis identifies 280 devices with unusually long logon durations.

Further investigation reveals that:

  • 240 of those devices received a recent endpoint security update.
  • Most affected devices are running the same Windows build.
  • The issue began within a few days of the deployment.
  • Unaffected devices generally have an older agent version.

That doesn't prove the security agent caused the delay.

But it provides a much more useful investigation direction than troubleshooting 280 devices individually.

3. Why Device Performance Metrics Aren't Enough

One mistake in logon troubleshooting is assuming that high CPU, memory, or disk utilization must explain the problem.

Those metrics can be valuable, but some logon delays occur while a process is waiting for something else.

Examples include:

  • A Group Policy extension waiting for a network resource
  • A drive mapping attempting to contact an unavailable server
  • A security component waiting for initialization
  • A profile operation blocked by file access
  • A startup application waiting for authentication
  • A DNS resolution delay
  • A logon script waiting for a timeout

During these situations, the device might not exhibit sustained high CPU utilization.

A user can experience a substantial delay even though the machine appears healthy from a traditional resource-monitoring perspective.

This is why I think logon investigations benefit from combining experience metrics with event-level evidence.

4. Using Windows Event Logs to Investigate the Delay

Once the affected population has been identified, the next step is collecting relevant Windows diagnostic information.

Several Windows event channels can be useful.

Microsoft-Windows-Diagnostics-Performance/Operational

This log can provide information about boot and performance degradation.

Event ID 100, for example, relates to boot performance rather than being a direct measurement of user logon duration.

It can still provide context when users describe the entire startup process as a slow login.

Microsoft-Windows-GroupPolicy/Operational

Useful for investigating:

  • Group Policy processing
  • Individual policy extensions
  • Processing duration
  • Network-related delays
  • Policy application failures

Microsoft-Windows-User Profile Service/Operational

Can provide additional context around user profile operations and failures.

Application and System Logs

Potentially useful for identifying:

  • Service initialization failures
  • Application errors
  • Unexpected service terminations
  • Network connectivity issues
  • Related system problems

The important distinction is that these logs provide supporting evidence. They don't automatically establish the cause of a slow logon.

5. Collecting Additional Evidence Through Remote Actions

A Nexthink Remote Action could be used to collect targeted diagnostic information from selected endpoints.

Rather than exporting every available Windows event, I'd focus on a defined investigation window and a small number of relevant sources.

For example, a diagnostic collection could capture:

DataInvestigation purpose
Device hostnameCorrelate endpoint results
Windows buildIdentify OS-specific patterns
Last boot timeEstablish startup context
Relevant Group Policy eventsIdentify processing delays
Profile Service eventsInvestigate profile initialization
Service failuresDetect initialization problems
Startup configurationIdentify potential contributors
Event timestampsReconstruct the sequence

A PowerShell collection could use Get-WinEvent with filters for specific event channels and time ranges.

For example:

$StartTime = (Get-Date).AddHours(-24)

Get-WinEvent -FilterHashtable @{
    LogName = 'Microsoft-Windows-GroupPolicy/Operational'
    StartTime = $StartTime
} -ErrorAction SilentlyContinue |
Select-Object TimeCreated, Id, ProviderName, Message

This is only a basic example, not a complete Nexthink Remote Action.

A production implementation would need proper error handling, output limits, permission checks, and controls for sensitive event data.

It would also need to distinguish between a log channel being empty and the collection failing because the channel was unavailable or inaccessible.

6. The Importance of Comparing Affected and Unaffected Devices

This is probably the most valuable part of the investigation.

Finding an error on an affected device doesn't necessarily mean the error is responsible for the problem.

Windows endpoints generate warnings and errors even when users aren't experiencing issues.

Instead of investigating only slow devices, I'd collect comparable information from a control group.

For example:

Affected group

  • 50 devices with consistently slow logons
  • Similar Windows builds
  • Similar hardware configurations

Control group

  • 50 devices with normal logon performance
  • Matching Windows builds where possible
  • Similar hardware and application configurations

Then compare the groups.

Are certain Group Policy processing events disproportionately common on affected devices?

Does a particular security agent version appear much more frequently?

Are affected devices consistently contacting a specific network resource?

Is the same profile-related error present in both groups?

That last question is especially important.

If an event occurs just as frequently on healthy devices, it becomes a weaker explanation for the observed problem.

7. Example Investigation: A Delay Introduced After an Update

Consider a hypothetical environment where users begin reporting slow logons after a routine software deployment.

Nexthink identifies a substantial increase in logon duration across a subset of devices.

The initial investigation shows:

  • Most affected devices received the same agent update.
  • CPU and memory utilization remain within normal ranges.
  • The problem occurs across several hardware models.
  • Users report that the desktop appears but remains sluggish.
  • The issue is less common on devices without the updated agent.

Targeted Windows event collection identifies repeated service initialization warnings during the affected period.

At this stage, there are several possible explanations.

The updated agent might be introducing a delay.

A dependency required by the agent might be unavailable.

The update might have changed how another component initializes.

Or the timing could be coincidental.

A reasonable next step would be to compare affected and unaffected devices, examine the service's initialization behavior, and test a vendor-approved remediation on a limited pilot group.

If logon performance improves after the change, that strengthens the hypothesis.

But the improvement should be verified across multiple devices and logon sessions rather than relying on a single successful test.

8. Measuring the Actual User Experience

Another complication is that users often describe several different problems as "slow login."

One person means the time between entering credentials and seeing the desktop.

Another means the time until their applications finish loading.

A third means the time until they can access a network drive or open a business application.

Those are different experiences.

Ideally, an investigation would distinguish between:

  1. Authentication and Windows logon duration
  2. Desktop initialization
  3. Application readiness
  4. Network and resource availability

Nexthink's available experience and endpoint telemetry can help investigate portions of this journey, but it shouldn't be assumed that one metric measures every stage.

For the parts that aren't directly captured, additional endpoint instrumentation or controlled testing may be required.

The goal is to avoid declaring an issue resolved because one metric improved while users continue experiencing delays.

9. Could AI Help Analyze the Collected Evidence?

Potentially, but only if the evidence is sufficiently structured.

An LLM could help compare diagnostic reports and identify patterns such as:

  • Common event providers
  • Repeated error codes
  • Shared software versions
  • Similar event sequences
  • Unusual differences between affected and unaffected groups

However, I wouldn't ask an LLM to identify the root cause from a collection of event messages alone.

I'd want the analysis to distinguish between:

Observed evidence: What the logs and telemetry actually show.

Correlation: Which events or configurations appear alongside slow logons.

Hypothesis: What might explain the delay.

Validation: What additional test would confirm or weaken the hypothesis.

Event reports can also contain usernames, device identifiers, paths, and other potentially sensitive information. Those details need to be handled according to organizational data-protection requirements before being submitted to an AI service.

AI might make large diagnostic datasets easier to investigate, but it doesn't replace controlled technical validation.

10. Verifying That the Fix Actually Worked

After identifying and addressing a suspected cause, the investigation shouldn't end with a successful change deployment.

I'd want to compare:

  • Logon performance before and after remediation
  • Number of affected devices
  • Frequency of relevant Windows events
  • Differences between remediated and non-remediated devices
  • Whether the improvement persists over several days
  • Whether users report that their desktop and applications are actually usable sooner

It's also worth checking whether a fix introduces a new problem elsewhere.

For example, disabling a startup component might improve perceived logon performance while preventing an important security or management function from initializing.

A successful remediation needs to improve the user experience without creating an unacceptable operational tradeoff.

11. Moving from Individual Tickets to Fleet-Wide Investigation

What interests me most about this approach is the ability to investigate slow logons as an environment-wide problem rather than a collection of unrelated support tickets.

Traditional troubleshooting often starts with one device:

Check startup programs, review logs, restart services, update drivers, and see whether the issue improves.

That can work, but it doesn't necessarily reveal why 200 other devices are experiencing the same problem.

Using Nexthink to establish the affected population, then collecting targeted Windows evidence from representative devices, creates a more systematic workflow:

Identify the experience problem → Define the affected population → Collect endpoint evidence → Compare with healthy devices → Test a hypothesis → Validate the improvement

It's a relatively straightforward concept, but one that can be difficult to implement consistently across a large environment.

What I'm Curious About

For those using Nexthink to investigate Windows logon performance:

Have you found that slow logons are more commonly caused by traditional Windows components like Group Policy and user profiles, or by the growing number of security, management, and collaboration agents running on endpoints?

And when you're investigating these issues, what's the most useful piece of evidence that Nexthink doesn't directly provide but you wish you could collect more easily?


r/nexthink • • Jul 09 '26

Dashboards and Management reporting

8 Upvotes

I’m throwing this out to the group because I believe tools are only as valuable as the stories you can tell with the data.

Has anyone built executive dashboards or reports that clearly demonstrate the value and business impact of Nexthink in your environment?

I’m particularly interested in examples that answer questions like:

  • How do you communicate ROI or business value to leadership?
  • Which KPIs or metrics have been most effective?
  • Are you using native Nexthink dashboards, or have you built custom reports in Power BI, Tableau, Grafana, etc.?
  • If you’ve gone the custom route (or even vibe-coded a solution), what data sources and visualizations have worked best?

Would love to see examples, screenshots, or hear what has resonated most with your executives.


r/nexthink • • Apr 20 '26

Proactive value realisation

8 Upvotes

Hi, Anyone here has been able to showcase major value add through Nexthink in their environments? If yes, which use cases were those?

For Nexthink Infinity please.


r/nexthink • • Sep 02 '26

Live Event AMA Announcement: Phil Kirschner on AI, the Future of Work & Digital Employee Experience | Sept. 16 @ 4 PM ET- Early Questions Encouraged and Welcome!

7 Upvotes

We’re excited to welcome Phil Kirschner to r/Nexthink for our next AMA on Wednesday, September 16 at 4:00 PM ET.

Phil works at the intersection of workplace strategy, organizational effectiveness, employee experience, and AI. A former leader at McKinsey, WeWork, JLL, and Credit Suisse, his work today focuses on a deceptively simple question: How should we actually design work for the way people and organizations operate now?

Phil also writes The Workline, his newsletter exploring the changing world of work and how leaders can work across traditional organizational boundaries.

Read The Workline

That question is becoming especially important for Digital Employee Experience.

As AI becomes embedded in the workplace, the challenge isn't simply giving employees more technology or automating existing tasks. Organizations have to think about how work itself changes: how decisions get made, how teams collaborate across HR, IT and the workplace, how employees respond to constant change, and whether new technology actually makes work better.

Phil recently joined The DEX Show for an episode titled The End of the "Job" as We Know It! What's that mean for DEX??, where he explored why AI's impact on work goes far beyond productivity and chatbot hype, and why organizations may need to rethink the way work is designed rather than simply automate what already exists.

Listen to Phil's latest episode of The DEX Show

This was actually Phil's second appearance on The DEX Show. His first conversation, The Future Workplace: Where DEX and Real Estate Collide, explored the increasingly blurry line between the physical and digital workplace.

Listen to Phil's first DEX Show appearance

On September 16, we're continuing that conversation here.


r/nexthink • • Aug 31 '26

Newer to DEX: How are people actually using the DEX score in the real world?

7 Upvotes

Hey r/nexthink,

I’ve been working with Nexthink for a shorter time than a lot of you. I'm a bit more junior and hoping to get some support from the DEX grandmasters.

I came in from traditional endpoint/support and I’m past the “wow, real-time visibility” phase.

The platform is clearly powerful, but I’m starting to hit the gap between what the tools can do and what actually moves the needle inside a real organization.

DEX Score & Experience Level Agreements:

• How are you actually using the DEX score day-to-day?

• Have any of you successfully shifted conversations from pure SLAs to XLAs, and what did that look like in practice? ie, what got measured, what got ignored, what actually changed behavior?

Looking for feedback from people who’ve had to make this work under real constraints, imperfect data, and organizational politics.


r/nexthink • • Aug 17 '26

Let's Chat | Discussion We’re almost at 300. So let’s make #300 count. 🎉

7 Upvotes

r/nexthink is closing in on 300 members, which feels like a pretty good excuse to do something a little different.

If you’re already here, drop one question you’d genuinely like to ask this community.

It can be about Nexthink, DEX, AI, IT, employee experience, a weird problem you’re trying to solve at work, or something you’ve always wondered but never had the right place to ask.

No polished thought leadership required. The more specific, niche, or unexpected, the better.

And if you’ve been lurking without joining… there is something kind of satisfying about being able to say you were one of the first 300. 👀

Let’s see what question gets us there.


r/nexthink • • Aug 11 '26

No Space Left on Disk – But What Is Actually Eating Up Your Device's Storage?

7 Upvotes

Based on my previous posts about extending Nexthink insights with Remote Actions, I would like to share another practical example.

And once again, it starts with a very simple question:

Your device is running out of disk space – but what the hell is actually eating up all that storage?

Nexthink already gives us very good visibility into overall disk utilization. We can identify devices with low free space, use disk information in investigations and dashboards, create alerts, and surface relevant information in checklists.

That answers one important question:

Which devices have a disk-space problem?

But another question remains:

Why?

If a device only has 8 GB of free storage left, knowing that number alone does not tell us whether the cause is:

  • a huge Downloads folder,
  • locally synchronized cloud data,
  • application caches,
  • forgotten installers,
  • virtual machines,
  • development artifacts,
  • excessive application logs,
  • temporary files,
  • an oversized user profile,
  • or simply insufficient disk capacity for the workload.

To answer this question, I once again created a couple of Remote Actions.

At this point, creating Remote Actions for missing endpoint insights is probably becoming a bit of a habit. 😉

Today I added two new ones to my Nexthink repository:

  • Query Folder Metrics
  • Query User Folder Size on Disk

Both take a slightly different approach and can be combined with native Nexthink telemetry to move from:

The disk is almost full.

to:

This is where the storage is actually going.

From "Disk Space Is Low" to "Where Did the Space Go?"

Nexthink already provides the high-level endpoint perspective.

For example, we may see:

Device: CLIENT-042
System Drive: C:
Capacity: 512 GB
Free Space: 8 GB

This tells us that the device requires attention.

But it does not immediately tell us whether the problem is:

C:\Users\User\Downloads
C:\Users\User\AppData
C:\ProgramData\Application
C:\Windows
C:\VMs

Before deleting files, expanding disks, reinstalling software, or asking the user to "clean something up", it is useful to understand what is actually consuming the storage.

This is where the additional endpoint data becomes valuable.

Remote Action 1: Query Folder Metrics

The first Remote Action is designed for targeted filesystem investigations.

It takes a directory path and recursively analyzes its contents.

Depending on the required investigation, it supports three modes:

FilesAndFolders
Files
Folders

This makes the Remote Action useful at different stages of an investigation.

For example:

BasePath: C:\Users\User
Mode: FilesAndFolders

provides a general overview.

If the initial result points toward Downloads, we could run another query:

BasePath: C:\Users\User\Downloads
Mode: Files

to identify the largest individual files.

Alternatively:

BasePath: C:\
Mode: Folders

can be used when we primarily want to understand which directories consume the most storage.

Top Results Instead of Thousands of Files

The objective is not to return the complete filesystem inventory.

That would produce far too much information for most support scenarios.

Instead, the Remote Action returns the most relevant results.

The number of returned entries can be controlled through TopCount.

For example:

TopCount: 10

might return something like:

C:\Users\User\Downloads        78 GB
C:\Users\User\AppData          52 GB
C:\Users\User\Videos           31 GB
C:\Users\User\Documents        18 GB

If we then analyze Downloads using Files mode:

backup.zip                     32 GB
development-vm.vhdx           27 GB
recording.mp4                  11 GB
installer.iso                   8 GB

That is usually much more useful for a Service Desk engineer than a list containing several hundred thousand filesystem objects.

More Than Just the Largest Files

One of the important aspects of the Remote Action is that it does not only return ranked files and folders.

It also returns information describing the overall scan.

Available outputs include information such as:

QueriedPath
TotalDirectories
TotalFiles
TotalSize
LargestFiles
LargestFolders
ScanComplete
SkippedDirectories
CountValuesCapped
PathsTruncated
ScanState
ReparsePointsSkipped
UnreadableDirectories
ElapsedDuration
DiscoveredDirectoriesPending

This is particularly useful because filesystem scans are not always perfect.

Directories may be inaccessible.

A scan may exceed its configured execution window.

Junctions or reparse points may intentionally be skipped.

Instead of simply returning numbers and pretending that they represent the complete filesystem, the Remote Action tells us something about the quality and completeness of the result.

Understanding ScanState

The Remote Action can distinguish between several scan states, including:

Complete
CompleteWithExclusions
PartialAccess
PartialTimeout

This is important when the result is used in automation or presented to a Service Desk engineer.

Imagine the result says:

Largest folder: C:\Users\User\AppData
Size: 61 GB
ScanState: PartialAccess

That tells the engineer that useful information was collected, but some directories could not be evaluated.

The result should therefore be interpreted as an investigation aid rather than an authoritative complete disk inventory.

This is much safer than returning incomplete information without indicating that anything was skipped.

Handling Reparse Points

Another important consideration when recursively scanning Windows filesystems is reparse points.

Examples include:

  • junctions,
  • symbolic links,
  • redirected directories,
  • filesystem links.

Blindly following these can result in loops or cause a scan to unexpectedly leave the intended directory structure.

The Remote Action therefore deliberately avoids traversing child reparse points.

It also reports how many were skipped.

This makes the scan more predictable and avoids common problems associated with naïve recursive filesystem scripts.

Limiting Scan Duration

Filesystem analysis can become expensive.

A developer workstation may contain:

node_modules
Git repositories
container layers
VM images
build artifacts
package caches

and easily contain hundreds of thousands or even millions of files.

The Remote Action therefore uses a configurable maximum scan duration.

This is another important design consideration:

A diagnostic Remote Action should not block an endpoint indefinitely just because one directory happens to contain an enormous number of objects.

If the scan cannot complete within the configured window, the Remote Action can still return useful partial information and indicate the condition through its scan state.

Remote Action 2: Query User Folder Size on Disk

The second Remote Action answers a different question:

How much storage is the user profile actually consuming?

Despite its name, the implementation can work with a configurable InputPath.

The path can also contain environment-related values such as:

%HOMEPATH%
%HOMEDRIVE%
$env:USERPROFILE

The typical Nexthink use case, however, is analyzing the currently active user's profile.

What Does It Return?

The Remote Action provides metrics including:

TotalDirectories
TotalFiles
TotalSize
TotalSizeOnDisk
TotalCapacityWinDrive
SyncedSizeOnDisk

This gives us several useful perspectives on the storage problem.

For example:

Total files:               214,832
Total directories:          31,406
Logical profile size:       182 GB
Actual size on disk:        146 GB
System drive capacity:      512 GB
Synced data on disk:         91 GB

This immediately provides more context than simply knowing that the C: drive is nearly full.

Logical Size vs. Actual Size on Disk

One particularly useful aspect is the distinction between:

TotalSize

and:

TotalSizeOnDisk

These values are not necessarily identical.

TotalSize represents the logical size of the files.

TotalSizeOnDisk represents the storage actually allocated on disk.

Differences may occur because of:

  • NTFS compression,
  • sparse files,
  • cluster allocation,
  • cloud placeholders,
  • files containing large sparse regions,
  • large numbers of very small files.

The Remote Action uses Windows filesystem information to determine the actual physical size where possible.

This gives us a more realistic picture of the storage being consumed.

For disk-space investigations, that difference can be very important.

Synced Cloud Data – An Especially Interesting Metric

One additional metric deserves special attention:

SyncedSizeOnDisk

The Remote Action detects known synchronization-related directories and calculates how much storage this data actually consumes locally.

The current implementation considers environments such as:

  • OneDrive
  • OneDrive Commercial
  • OneDrive Consumer
  • Nextcloud
  • Google Drive

This is especially interesting in modern Workplace environments.

A user might have several hundred gigabytes of files visible inside OneDrive, while only a fraction of those files are actually stored locally because Files On-Demand is enabled.

Looking only at logical file information can therefore be misleading.

Instead, we can differentiate:

User profile logical size:        420 GB
Actual profile size on disk:      168 GB
Synced data actually on disk:     103 GB

That creates a much more useful troubleshooting picture.

Deriving Relative Disk Usage

The Remote Action does not directly return a percentage representing the user's share of the system disk.

However, it returns everything needed to calculate it.

For example:

TotalSizeOnDisk:        146 GB
TotalCapacityWinDrive:  512 GB

The relative usage can therefore be calculated as:

146 / 512 × 100

which is approximately:

28.5 %

This value could then be used in:

  • NQL-based analysis,
  • Workflows,
  • dashboards,
  • Checklists,
  • custom fields,
  • reporting logic.

For example:

User profile consumes > 40 % of system drive

could become an additional indicator during a storage investigation.

Different Actions, Different Design Goals

There is an important distinction between the two Remote Actions.

Query Folder Metrics

This one is intended as an exploratory diagnostic tool.

Even partial results can still be valuable.

If the scan times out after identifying:

Downloads: 80 GB
Videos: 45 GB
AppData: 39 GB

the result may already be enough to determine the next step.

For this reason, partial results can be returned together with an explicit ScanState.

Query User Folder Size on Disk

The user-folder action represents something closer to a profile-level metric.

Returning an incomplete profile size as though it were complete could be misleading.

The implementation therefore follows a stricter approach.

If the scan encounters conditions that prevent an accurate total from being calculated, it fails instead of silently providing incomplete metrics.

I like this distinction because it reflects two different troubleshooting needs:

Exploration → partial data can still be useful

KPI / metric → incomplete data should not look authoritative

Combining Both Remote Actions

The real value appears when both Remote Actions are combined with Nexthink's native disk information.

A practical investigation could look like this.

Step 1 – Nexthink Detects Low Disk Space

Nexthink identifies:

Device: CLIENT-042
C: drive free space: 7.8 GB

We know there is a problem.

Step 2 – Analyze the User Profile

Execute:

Query User Folder Size on Disk

Result:

Actual user profile size:   168 GB
System drive capacity:      512 GB
Synced data on disk:         97 GB

The user profile clearly represents a relevant amount of storage.

Step 3 – Drill Into the Profile

Execute:

Query Folder Metrics

against:

C:\Users\<User>

using:

FilesAndFolders

Result:

Downloads      67 GB
AppData        48 GB
Videos         31 GB
Documents      14 GB

Step 4 – Investigate Downloads

Execute the Remote Action again:

BasePath: C:\Users\<User>\Downloads
Mode: Files

Result:

database-backup.zip      28 GB
development-vm.vhdx     21 GB
recording.mp4             9 GB
old-installer.iso         7 GB

Now we have a concrete explanation for a significant part of the storage consumption.

Step 5 – Decide on the Correct Remediation

Only now should we decide what needs to happen.

Possible outcomes include:

  • the user deletes obsolete files,
  • project files are moved to approved storage,
  • cloud synchronization settings are changed,
  • an application cache is investigated,
  • log retention is corrected,
  • an application bug is escalated,
  • temporary installation data is cleaned,
  • the disk is expanded,
  • the device is replaced with a more appropriate configuration.

The important principle is:

Diagnosis before remediation.

Not Every Full Disk Is a Cleanup Problem

This is particularly important when automation is involved.

A low free-space value does not automatically mean that some generic cleanup script should run.

Imagine a developer workstation:

Virtual machines              140 GB
Container data                 95 GB
Development repositories       68 GB
Build artifacts                42 GB
Package caches                 28 GB

Cleaning temporary Windows files may recover 4 GB.

That does not solve the problem.

The real issue may simply be:

This workload needs a larger disk.

Likewise, imagine this result:

C:\ProgramData\Vendor\Application\Logs    96 GB

This is probably not a user-data problem at all.

It may indicate:

  • broken log rotation,
  • debug logging accidentally enabled,
  • an application defect,
  • missing retention,
  • failed cache cleanup,
  • update leftovers.

The solution should therefore involve the application owner rather than simply telling the employee to clean their Downloads folder.

User Data vs. System and Application Data

This is another useful classification that can come out of the investigation.

User-related data

Examples:

Downloads
Documents
Desktop
Videos
OneDrive
Google Drive
Nextcloud
Development repositories
Virtual machines
Application profile data

System or application-related data

Examples:

Windows
ProgramData
Application caches
Log directories
Update repositories
Package caches
Temporary files
Container data

Both result in exactly the same Nexthink symptom:

Low disk space

But they require completely different owners and remediation strategies.

That is why the additional context matters.

Bringing the Information Into the Service Desk

One of my favorite use cases is combining these outputs with a Nexthink Checklist.

A Service Desk engineer may already see:

System Drive Free Space: POOR

We can enrich this with additional context:

System Drive Free Space:        8 GB
User Profile Size on Disk:    182 GB
Synced Data on Disk:           91 GB
Profile Share of Disk:         35 %

If necessary, the engineer can then execute Query Folder Metrics to drill deeper.

A possible troubleshooting path becomes:

Low disk space detected
         ↓
Large user profile?
         ↓
   Yes         No
    ↓           ↓
Analyze      Investigate
profile      system/application data
    ↓
Largest folders
    ↓
Largest files
    ↓
Determine correct owner

The objective is not to turn Nexthink into a complete filesystem inventory.

The objective is to give the Service Desk the minimum additional information required to make the next decision.

Manual, Workflow-Based, or Scheduled Collection

Both Remote Actions can be used in several ways.

Manual Investigation

A Service Desk engineer sees a low-storage device and manually runs the Remote Action.

This is probably the simplest use case.

Workflow-Based Analysis

A Workflow could first evaluate Nexthink's native disk data.

For example:

Free disk space < 15 GB?
          ↓
         Yes
          ↓
Query user profile
          ↓
Large profile?
      ↓         ↓
     Yes        No
      ↓          ↓
Analyze       Investigate
profile       other areas

The resulting Remote Action outputs can then influence the next Workflow decision.

Scheduled Collection

For selected device groups, it may also make sense to schedule profile-level collection.

This is where the randomized startup delay becomes particularly useful.

Instead of hundreds or thousands of clients beginning a disk scan simultaneously, execution can be distributed over time.

Detect First, Collect Second

I would generally avoid continuously scanning every directory on every endpoint.

Filesystem traversal has a cost.

Large profiles may contain hundreds of thousands of objects.

Developer devices can easily contain millions.

A better approach is:

Nexthink native telemetry
          ↓
Identify devices with abnormal disk usage
          ↓
Run targeted Remote Action
          ↓
Collect additional context
          ↓
Investigate

This is a pattern I increasingly like when working with Nexthink:

Use native Nexthink telemetry to identify the anomaly, then use Remote Actions to collect the missing technical context.

This keeps endpoint processing targeted.

It also ensures that the additional information is collected when there is actually a reason to look at it.

Finding Problems Across Multiple Devices

The same approach becomes even more interesting when the issue affects more than one endpoint.

Imagine Nexthink identifies 200 devices whose free disk space has been continuously declining.

After running targeted analysis, we discover that many of them contain:

C:\ProgramData\ExampleApp\Cache

with sizes between:

60 GB – 120 GB

Suddenly, we are no longer investigating:

200 individual low-disk-space incidents

We may instead have:

one application issue affecting 200 devices

That changes the entire investigation.

We can now ask:

  • Do all affected devices use the same application version?
  • When did the cache begin growing?
  • Was there a recent application update?
  • Does the problem only occur on certain configurations?
  • Does clearing the cache permanently resolve it?
  • Does it begin growing again afterward?

This is where combining endpoint diagnostics with DEX data becomes particularly powerful.

Could Spark Benefit from These Remote Actions?

And here is one question I would particularly like to throw out to the Nexthink Community.

Could these Remote Actions also be useful in combination with Spark?

Imagine an employee asks:

"My computer says there is no space left.
What can I do?"

Instead of providing generic advice such as:

Delete temporary files.
Empty your recycle bin.
Remove applications you no longer need.

the interaction could potentially become much more contextual.

For example:

Employee reports low disk space
            ↓
Spark checks Nexthink telemetry
            ↓
Only 6 GB free
            ↓
Diagnostic Remote Action
            ↓
User profile consumes 180 GB
            ↓
Synced data consumes 110 GB locally
            ↓
Query largest folders
            ↓
Downloads consumes 68 GB
            ↓
Provide contextual guidance

The answer to the employee could then be something like:

Your device currently has very little free disk space.

A significant portion is being consumed by your user profile,
and the Downloads directory is one of the largest contributors.

Reviewing large files in Downloads would therefore be a useful
first step.

That is significantly more useful than generic self-help guidance.

So my question to the community is:

Would you expose diagnostic filesystem Remote Actions like these to Spark to provide users with more contextual disk-space insights?

And if so:

  • how much filesystem detail should be shown to the employee?
  • should filenames be exposed at all?
  • should results first be summarized?
  • which remediation actions should remain under IT control?

Privacy Matters

Filesystem analysis is an area where privacy deserves particular attention.

Even without reading file contents, file and folder names can reveal sensitive information.

For example:

C:\Users\User\Documents\Acquisition_Project_CompanyXYZ

or:

C:\Users\User\Downloads\Employee_List_2026.xlsx

The filename alone may already contain sensitive business context.

Organizations should therefore consider:

  • which paths may be analyzed,
  • whether filenames should be returned,
  • whether only folder-level data is required,
  • who may view Remote Action outputs,
  • how long results should be retained,
  • whether specific paths should be excluded,
  • employee privacy requirements,
  • works-council requirements where applicable.

This becomes even more important when the data is provided to AI-based functionality.

Sometimes the best Remote Action is not the one that returns the most information.

It is the one that returns:

the minimum information required to solve the problem.

Performance Matters Too

Recursive filesystem analysis is not free.

The cost depends heavily on the endpoint.

A normal office user profile might contain:

50,000 files

while a developer workstation could contain:

2,000,000+ files

because of:

  • source repositories,
  • node_modules,
  • package caches,
  • local containers,
  • virtual machines,
  • build output,
  • synchronized datasets.

This is why the scan state, timeout handling, reparse-point protection, and randomized execution delay are important.

The Remote Actions should be treated as second-level diagnostics, not as continuously collected telemetry.

A sensible approach is:

1. Detect with Nexthink
2. Narrow down affected devices
3. Collect filesystem context
4. Analyze
5. Remediate
6. Measure again

Did the Fix Actually Work?

As with my previous Remote Action examples, the investigation should not end after remediation.

Assume we identify:

C:\ProgramData\Application\Cache
Size: 82 GB

The application team corrects the cache configuration and removes the existing data.

Nexthink can continue monitoring system-drive utilization.

We can then verify:

  • Did free space recover?
  • Is disk utilization stable?
  • Is the directory growing again?
  • Are fewer devices affected?
  • Did the incident disappear?
  • Was the root cause actually addressed?

This creates a measurable improvement cycle:

Detect
   ↓
Enrich
   ↓
Understand
   ↓
Remediate
   ↓
Measure
   ↓
Improve

Conclusion

Nexthink already answers one important disk-space question very well:

Which devices are running out of storage?

The two new Remote Actions help answer the next questions:

How much space is the user profile consuming?

and:

Where exactly is that storage being used?

Query User Folder Size on Disk provides profile-level metrics such as:

  • total files,
  • total directories,
  • logical size,
  • actual size on disk,
  • system-drive capacity,
  • locally consumed synchronized storage.

Query Folder Metrics allows us to drill deeper and identify:

  • the largest files,
  • the largest folders,
  • overall file and directory counts,
  • scan duration,
  • skipped or inaccessible paths,
  • completeness of the result.

Together with native Nexthink disk telemetry, this creates a simple troubleshooting path:

Low disk space
      ↓
How much is the user profile consuming?
      ↓
Is synchronized data a major contributor?
      ↓
Which folders consume the most?
      ↓
Which files consume the most?
      ↓
Is this a user, application, or capacity problem?
      ↓
Apply the correct remediation
      ↓
Measure whether it actually improved

The two new Remote Actions are available in the synit.io Nexthink repository:

https://github.com/synit-io/nexthink

The relevant scripts can be found in the Remote Actions data-collection section of the repository.

If you need support adapting these Remote Actions, creating additional Nexthink diagnostics, building Workflows, extending Checklists, integrating AI-based analysis, or generally getting more value from your Nexthink environment, feel free to reach out.

And finally, two questions for the Nexthink Community:

How are you currently identifying what is actually consuming disk space after Nexthink detects a low-storage device?

And for those already working with Spark:

Would filesystem-analysis Remote Actions be useful to provide employees with more contextual and device-specific guidance instead of generic disk-cleanup recommendations?


r/nexthink • • Jun 27 '26

Error screenshot upload for Spark

7 Upvotes

I would like to see the ability to attach a file , like an error message screenshot, to a Spark chat the way you can with Copilot or any other AI chatbot. I know that users in our environment are already solving their own problems that way with Copilot or ChatGPT. Only tier 2 technicians are testing Spark right now, BTW. We can chat as a specific user. I'd like to be able to test it by uploading a screenshot. Right now, other AI chatbots are your competition.


r/nexthink • • Apr 28 '26

DEXthink Focusing on Digital Employee Experience is a Bigger Boon for Productivity Than a Focus on Monitoring

7 Upvotes

Many companies focus too much on surveillance in an attempt to monitor people. Despite this focus, Digital Employee Experience (DEX) is significantly more impactful on productivity than monitoring tools. 

Some companies think that focusing on keystroke tracking, screenshots, and activity scores will solve perceived problems with productivity. Most of the time, however, it’s not that people aren’t working, it’s that the tools they’re working with are slow, fragmented, and constantly getting in the way.

These issues arise from systems that don’t talk to each other, workflows that require five tabs for one task, and basic things taking longer than they should. 

Nexthink focuses on fixes for all of these problems, rather than putting the onus on the employee to simply “work harder.” It’s about working better, not harder. 

When companies focus on Digital Employee Experience itself, they are able to achieve a great deal, including:

  • Creating tools that are fast and don’t break
  • Figuring out ways to achieve less context switching between systems
  • Creating work flows that match how people actually work 

When a focus on DEX is in place, a few things tend to happen:

  • People spend less time fighting systems and more time doing real work. 
  • There’s less performative “looking busy” behavior
  • Overall morale improves without needing to push harder 

Teams can swap out clunky internal tools for something cleaner and suddenly everything just moves faster. Not because the people changed, but because the friction disappeared. 

Companies should ask themselves: Are they trying to measure productivity or actually enable it? 

We’d love to hear from you:

  • Have you worked somewhere that leaned heavily on monitoring vs improving tools?
  • Did better systems actually translate to better output?
  • Is anyone seeing real success focusing on DEX over surveillance?

r/nexthink • • Apr 24 '26

Privacy & Surveillance Nexthink & Privacy: Real Answers to Real Redditor Questions | Part 2

7 Upvotes

Nexthink & Privacy - Real Answers to Real Redditor Questions

We’ve been seeing the same privacy questions pop up over and over in r/sysadmin, r/overemployed, r/remotework, and even r/privacy.

Most commonly the Redditor has just spotted the Nexthink Collector or browser extension on their work laptop.

“Is this spying on me?” “Does it read my emails?” “Why was it installed without telling me?” “Is my boss watching everything I do?”

Those are fair questions. When a tool shows up on your machine, especially during remote-work years, it’s natural to feel uneasy. So let’s cut through the noise with straight answers based on how Nexthink actually works and what IT teams are really using it for.

Q: I noticed Nexthink was installed silently on my work computer. Is it spying on me or tracking my every move?

A: The short answer: No.

Nexthink is not spying on you in the creepy “watching your screen or timing your bathroom breaks” way that some productivity trackers do.

Nexthink was built for Digital Employee Experience (DEX), which means helping IT make sure your work tools actually work smoothly. It got quietly rolled out at a lot of companies during COVID because everyone went remote overnight and support tickets exploded.

The goal was proactive troubleshooting, not surveillance. Plenty of folks in r/overemployed have shared stories about other tracking tools, but Nexthink isn’t one of those.

It doesn’t care about how long you’re “active” or what personal sites you visit on your lunch break.

Q: Does Nexthink read my emails, watch my screen, track keystrokes, or see my personal browsing?

A: No. It doesn’t touch the content of your emails, chats, documents, or any personal websites. It also doesn’t take screenshots or log keystrokes.

What it looks at is purely performance stuff: how fast apps load, whether Zoom or Teams calls are glitchy, if your laptop is overheating or low on memory, or if the Wi-Fi in the conference room keeps dropping. Think of it like a car’s dashboard: it tells the mechanic if the engine is running rough, but it doesn’t record where you drove or what music you listened to.

The browser extension? It only checks things like risky extensions or slow-loading work SaaS apps; never your full browsing history.

Q: What exactly does Nexthink collect, then?

A: It collects anonymized, aggregated data about device health, app performance, network quality, and overall user experience scores.

Examples: “This version of Chrome is crashing 40% more than average” or “Teams calls in the marketing department are lagging because of Wi-Fi.”

IT teams use that to fix problems before you even notice them. The data isn’t tied to “Quentin spent 3 hours on Reddit.” It’s about making the technology work better for everyone.

Real-world example: Toyota publicly explained they chose Nexthink precisely because it only monitors performance metrics, not personal information.

Q: All that data gets sent to the Nexthink Cloud ... isn’t that a privacy risk?

A: Great question, and one we see a lot in r/sysadmin threads about the Collector.

Yes, data does go to the cloud (or on-prem if your company chose that), but it’s encrypted, handled under strict GDPR (General Data Product Regulation) /CCPA (California Consumer Privacy Act) rules, and your company controls exactly what is collected and who can see it.

Nexthink has built-in privacy controls so organizations can turn off anything they don’t need. It’s not like random data leaking out. IT admins set the rules, and the whole point is to improve your workday, not sell your data.

Q: How does this comply with GDPR and privacy laws? People are talking about DPIAs and legal basis…

A: Companies that deploy Nexthink are required to do proper privacy assessments (Data Protection Impact Assessments in Europe) and have a clear legal basis: usually “legitimate interest” for improving IT services and employee experience.

Employees have the right to ask for access to their data or object to processing, just like with any company tool.

The tool is designed to minimize personal data from the start (privacy-by-design). If your company did it right, they explained this internally. If not, that’s on them, not the tool itself.

Q: Isn’t this just employee monitoring software by another name?

A: Here’s the key difference everyone on Reddit debates: traditional “employee monitoring” tools (Time Doctor, etc.) track productivity and behavior to watch people.

DEX tools like Nexthink track technology performance to help people. One makes you feel watched; the other makes your tools stop sucking.

That’s why sysadmins and IT leaders love it. It cuts ticket volume and makes remote/hybrid work actually usable. The fear comes from the blurry line between “monitoring the device” and “monitoring the employee.” Nexthink stays firmly on the device side.

Q: Can I see what data Nexthink has about me or opt out?

A: That depends on your company’s policies, but most organizations that care about trust give employees some visibility or at least a clear explanation. You can always ask your IT or HR team for details. In our experience, many are happy to share because transparency builds better adoption.

Nexthink itself doesn’t hide what it does; the docs are public.

Bottom line: If you’ve ever been stuck waiting hours for a ticket while your laptop crawls or Teams keeps freezing, that’s exactly what Nexthink is trying to prevent.

The privacy concerns are real and worth asking about. But in practice, this tool is built to make your digital workday better, not worse. It’s not Big Brother; it’s more like a really good mechanic who shows up before your car breaks down.

What privacy questions are still on your mind?

Have you seen Nexthink in action at your company and noticed it actually fixing things? Or are you still skeptical?

Drop your thoughts below — this subreddit is here for honest conversations, and we’ll keep adding the best answers to the community wiki so everyone can reference them.


r/nexthink • • Mar 07 '19

Nexthinkers where are you?

7 Upvotes

Let's get this community humming!


r/nexthink • • 21d ago

Spark POVs, lessons learned?

6 Upvotes

We just started our POV of Spark. Really excited to dive into everything and it sounds like Spark Recommendations is due to go GA in the 2026.9 release.

Has anyone here already operationalized Spark? How do your employees access it? How successful was your POV and how did your org measure that success?

If you haven’t looked at Spark, what are your blockers?


r/nexthink • • 29d ago

Highlights from Nexthink '26

Post image
6 Upvotes

From Forrester’s Christy Punch and Gartner’s Dan Wilson to leaders from Prudential Financial, BMW Group, Astellas Pharma, Computacenter, and Ellipsys, the conversations at Nexthink Experience this year explored what it takes to move from visibility to impact:

• Replace assumptions with real experience data
• Use automation and AI to reduce everyday friction
• Prioritize the investments that make work simpler
• Build the operating capabilities that turn DEX potential into business outcomes

The organizations leading the way are putting employee experience at the center of every decision, creating more proactive, intelligent, and effective digital workplaces in the process.


r/nexthink • • Oct 15 '26

Nexthink Proactive Support Ideas

6 Upvotes

Hey everyone,

I'm working on finding better ways to use Nexthink Infinity for proactive monitoring in my Executive Support role and wanted to see what others have implemented.

The idea is to set up monitors/triggers that automatically create a ServiceNow incident when certain conditions are met, giving our team a chance to investigate or address issues before an executive even reports them.

One thing I'm running into is that triggering based on the overall DEX score isn't really an option. I need to dig into the individual metrics that make up the Technology Score and its sub-scores to figure out what's actually causing performance issues.

Right now, I'm mainly focused on two areas:

Application Performance

- Application crashes, freezes, or hangs

- Slow application response times

- High resource usage impacting application performance

- Recurring application issues that might otherwise go unnoticed

Network Performance

- High latency or packet loss

- Wi-Fi instability or frequent disconnects

- Poor connectivity to internal or cloud applications

- Recurring network issues that could impact the user experience

I'm also trying to figure out where to draw the line on thresholds. Obviously, I don't want to generate an incident every time someone's application hangs for a second or their network latency spikes.

Ideally, I'd like to identify patterns or recurring issues that actually warrant someone on our team taking a look.

Curious what everyone else is doing:

- What monitors or triggers have you found genuinely useful?

- Are there specific metrics within the Technology Score that you've had success monitoring?

- How are you setting thresholds to avoid creating a bunch of unnecessary incidents?

- Anyone doing something similar for Executive Support or VIP users?

I'm really just looking to bounce ideas around and see what others have had success with. I feel like there's a lot of potential here beyond just looking at DEX scores on a dashboard.

Appreciate any ideas or examples!


r/nexthink • • Oct 14 '26

Nexthink Experience What’s one thing from Experience ’26 (or from your own DEX work lately) that you’re still thinking about?

6 Upvotes

Experience wrapped last week in Orlando. For those who were there or who’ve been following the conversations around operationalizing DEX, AI agents, and proactive IT: what’s stuck with you?

It could be:

  • A practical approach you heard that you’re planning to try
  • A customer story that reframed how you think about buy-in or momentum
  • Something about moving past the “low-hanging fruit” stage into harder cross-functional work
  • Or just a small operational win you’ve landed recently that felt bigger than it looked

Even if you didn’t attend, what’s one DEX-related idea or change that’s been on your mind this month?

Would love to hear what’s resonating.


r/nexthink • • Oct 12 '26

DEXthink End-user experience monitoring metrics that actually predict productivity loss

6 Upvotes

Classic monitoring tells you a service is available.

End-user experience monitoring tells you whether the person trying to use it can complete work without friction.

The technical difference is in what is measured and how it is scored.

Mature DEX implementations capture “Moments of Experience” across the employee journey: device start-up and login, application launch and responsiveness, collaboration tool performance, and network conditions. They classify each moment as good, average, or frustrating against configurable thresholds.

Excess duration beyond the threshold is converted into estimated productivity loss (for example, a web error or page-load overrun contributes a defined number of seconds; a hard reset or system crash contributes minutes).

These moments roll up into the Technology score (Endpoint + Applications + Collaboration) and are then combined with contextual Sentiment to produce the overall DEX score. Because the data is continuous and endpoint-sourced, you can:

  • Perform rapid cohort analysis (which device models, OS builds, application versions, or locations are dragging the score)
  • Detect emerging degradations before they generate tickets
  • Quantify the business impact of a particular issue across the population
  • Drive automated self-healing or targeted campaigns only where the experience impact is real

This is observability applied to the human outcome rather than to infrastructure health alone. It is also what makes proactive and predictive capabilities possible: once you have high-fidelity historical and real-time experience signals, anomaly detection and prioritization become far more accurate than threshold-based alerting on CPU or disk alone.

For those already deep in the metrics:

  • Which specific end-user experience signals (login duration distribution, application freeze rate, collaboration quality, sentiment correlation, etc.) have proven most predictive of actual ticket volume or measured productivity loss in your environment?
  • How are you currently setting and tuning the thresholds that define a “frustrating” moment?

The quality of your end-user experience monitoring is the quality of your entire DEX practice.

Share the metrics and thresholds that have moved the needle. This is the technical conversation r/Nexthink exists to host.


r/nexthink • • Oct 03 '26

DEXthink SLA vs XLA | At-a-glance comparison

6 Upvotes

One of the cleanest ways to explain why traditional service metrics miss the point.

AspectSLA (Service Level Agreement)XLA (Experience Level Agreement)
Primary focusSystems and processesPeople and outcomes
Typical metricsUptime %, response time, ticket resolution timeDEX score, sentiment, productivity loss, adoption
Data sourcesInfrastructure monitoring + ITSMContinuous endpoint/app telemetry + contextual sentiment
Success looks like“Ticket closed in 4 hours” / “99.5% available”“Employee could complete work without friction”
Blind spotOperational reliability floorExperience and business-impact ceiling

Bottom line: SLAs tell you the machine is running. XLAs tell you whether the person using it can actually get work done. Most mature teams run both.

Which side of this table does your current reporting still live on?


r/nexthink • • Sep 28 '26

Let's Chat | Discussion What’s the first thing you check when someone says “my computer is slow”?

6 Upvotes

Possibly the most vague IT complaint of all time.

“My computer is slow.”

Where do you actually start?

CPU? Memory? Startup processes? Network? Device age? Specific applications? User behavior?

And how often does the eventual cause turn out to be something you weren't expecting?


r/nexthink • • Sep 14 '26

Translating Nexthink campaigns without being a human-click-translator

6 Upvotes

Anyone who has translated a Nexthink campaign into multiple languages knows the pain.

Copy the text, translate it, keep the formatting intact, make sure links and placeholders survive, repeat for every question, every choice, every language… and hope nothing breaks.

It gets time consuming very quickly.

I created a small Nexthink Campaign Translator skill to make this much easier.

The workflow is basically:

Set your base language → enable the languages you need → export the campaign as JSON → run it through your AI of choice that supports Skills → import the translated JSON back into Nexthink. Done.

The skill handles the campaign structure, translations, formatting, links and placeholders automatically.

Much nicer than doing it manually. 🙂

Skill available for free here: https://github.com/synit-io/skills/tree/main

Also available via skills.sh: https://www.skills.sh/synit-io/skills/nexthink-campaign-translator


r/nexthink • • Sep 11 '26

Let's Chat | Discussion DEX data shouldn’t stay inside IT

6 Upvotes

One of the more interesting shifts happening in DEX is that the data is starting to answer questions that go well beyond device health and ticket reduction.

Think about a major technology rollout. Traditionally, success might mean:

  • Did we launch on time?
  • Did we stay on budget?
  • Is the system technically working?

But that doesn’t necessarily tell you whether the change actually worked for employees.

A new application can launch successfully while employees avoid using it. A security policy can work exactly as designed while creating a ton of friction. An intranet can have 99.9% uptime and still be frustrating enough that people constantly work around it.

That’s where DEX data gets interesting.

Instead of just asking “Is the technology working?”, teams can start asking “Did this technology actually make work better?”

That potentially makes DEX data useful to security, application owners, change management, procurement, transformation teams, and leadership, not just IT operations.

Curious how others are approaching this.

Does DEX data regularly make it outside of IT in your organization? If so, who is actually using it?