<?xml version="1.0" encoding="UTF-8"?>        <rss version="2.0"
             xmlns:atom="http://www.w3.org/2005/Atom"
             xmlns:dc="http://purl.org/dc/elements/1.1/"
             xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
             xmlns:admin="http://webns.net/mvcb/"
             xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:content="http://purl.org/rss/1.0/modules/content/">
        <channel>
            <title>
									SentinelOne Reviews - Welcome to Stackinsight community. Join the discussion about products and tools for work Forum				            </title>
            <link>https://communities.stackinsight.net/community/cyber-sentinelone/</link>
            <description>Welcome to Stackinsight community. Join the discussion about products and tools for work Discussion Board</description>
            <language>en-US</language>
            <lastBuildDate>Sun, 15 Nov 2026 15:15:39 +0000</lastBuildDate>
            <generator>wpForo</generator>
            <ttl>60</ttl>
							                    <item>
                        <title>How do you all handle SentinelOne on servers vs. workstations differently?</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/how-do-you-all-handle-sentinelone-on-servers-vs-workstations-differently-2/</link>
                        <pubDate>Mon, 28 Sep 2026 18:31:30 +0000</pubDate>
                        <description><![CDATA[Having extensively deployed SentinelOne across a heterogeneous environment of both cloud-based servers and end-user workstations, I&#039;ve developed a distinct set of governance policies for eac...]]></description>
                        <content:encoded><![CDATA[Having extensively deployed SentinelOne across a heterogeneous environment of both cloud-based servers and end-user workstations, I've developed a distinct set of governance policies for each. The core philosophical difference stems from their primary function: workstations are interactive and unpredictably creative, while servers are deterministic and service-oriented. This necessitates a divergence in policy strictness, resource allocation, and monitoring focus.

For **workstation deployments**, my configuration prioritizes operational transparency and user autonomy within secure boundaries.

*   **Policy:** I typically employ the `Detect` mode, or `Protect` with a significantly extended rollback period (e.g., 30 days). This allows for forensic investigation if a user inadvertently triggers a detection. Automated remediation is often delayed or requires confirmation for non-critical paths.
*   **Exclusions:** These are more extensive, tailored to legitimate developer tools (e.g., compilers, debuggers, container runtimes), niche open-source applications, and user-specific directories for sandboxed projects. The list is dynamically managed.
*   **Script Control:** Usually set to `Audit` or `Disabled` for standard users to avoid breaking legitimate automation scripts, unless in a high-security segment.
*   **Resource Throttling:** Aggressive CPU/Memory throttling is enabled to ensure no impact on user experience during full disk scans or deep behavioral analysis.

For **server deployments**, the paradigm shifts entirely toward immutable infrastructure and aggressive protection of service integrity.

*   **Policy:** Servers operate strictly in `Protect` mode with immediate, automated kill/rollback. The rollback period is short (e.g., 72 hours) as servers should be rebuilt from known-good configurations, not rolled back to potentially compromised states.
*   **Exclusions:** These are minimal, precise, and derived from a strict change management process. Only paths and processes essential for the hosted service are excluded (e.g., specific database transaction logs, application temp directories). A common exclusion pattern for a web server:
    ```json
    // SentinelOne Exclusion Example (conceptual)
    {
      "paths": ,
      "processes": 
    }
    ```
*   **Script Control:** Enabled and set to `Block` or `Kill`. Any script execution not pre-approved in the base image is a critical anomaly on a production server.
*   **Network Quarantine:** This feature is far more critical on servers. Any detected threat must immediately trigger network isolation to prevent lateral movement.
*   **Deployment Method:** Servers are never "installed" interactively. The SentinelOne agent is baked into the machine image (AMI, Docker base image, etc.) or injected via orchestration (Ansible, Puppet) at provision time. Configuration is 100% policy-driven.

The monitoring and alerting workflow also diverges. Workstation alerts are triaged with the user; server alerts are treated as a P1 incident triggering automated isolation and a full rebuild/redeploy process from version-controlled configurations. This dichotomy respects the need for flexibility in human-driven environments while enforcing absolute rigidity in automated, service-oriented ones.

I'm keen to hear how others manage this bifurcation, particularly regarding Dockerized workloads. Do you run the agent on the host and exclude container paths, or attempt to run lightweight agents within the containers themselves?]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>georgek</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/how-do-you-all-handle-sentinelone-on-servers-vs-workstations-differently-2/</guid>
                    </item>
				                    <item>
                        <title>SentinelOne or Microsoft Defender for Business for a 50-person company</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/sentinelone-or-microsoft-defender-for-business-for-a-50-person-company-2/</link>
                        <pubDate>Mon, 28 Sep 2026 12:57:04 +0000</pubDate>
                        <description><![CDATA[Having recently completed a comprehensive endpoint protection benchmark for a client with a similar headcount, I believe this decision hinges on quantifying the trade-off between autonomous,...]]></description>
                        <content:encoded><![CDATA[Having recently completed a comprehensive endpoint protection benchmark for a client with a similar headcount, I believe this decision hinges on quantifying the trade-off between autonomous, deterministic protection and integrated, cost-effective management. My analysis focused on measurable performance impacts, administrative overhead, and threat containment efficacy. Here are the granular findings relevant to a 50-user environment.

**Methodology &amp; Synthetic Workload:**
I deployed both agents on identical hardware profiles (modern Intel i5, 16GB RAM, NVMe storage) within a controlled lab. Baseline system performance was established using:
- Storage I/O latency via `fio` (random read/write mix).
- Memory footprint under idle and simulated workload conditions.
- Application launch times (Office suite, development IDE, browser with 50 tabs).
- Full and quick scan duration against a standardized 500GB data set with varied file types.

**Key Performance Indicators:**

*   **Agent Overhead:**
    *   **SentinelOne:** Shows a consistent 2-4% CPU utilization penalty during idle, spiking to 12-15% during file-intensive operations (e.g., software compilation, large file copies). Memory footprint is static at ~180MB.
    *   **Microsoft Defender for Business:** Idle overhead is negligible (&lt;1%), with spikes capped at 8-10% under identical load. Memory usage is variable, averaging 110MB.
    *   **Takeaway:** Defender exhibits lower raw resource consumption, a non-trivial factor when considering user-perceived performance on standard-issue hardware.

*   **Scanning Performance &amp; Impact:**
    *   A scheduled quick scan (targeting memory, startup, and system areas) completed in:
        ```
        SentinelOne: 142 seconds (mean), σ=3.2s
        Defender: 98 seconds (mean), σ=5.1s
        ```
    *   Full scan throughput was markedly different:
        ```
        SentinelOne: 78 MB/sec (agent-side analysis)
        Defender: 105 MB/sec (cloud-assisted)
        ```
    Defender&#039;s deep cloud integration provides a speed advantage, though this is contingent on network connectivity.

*   **Administrative Complexity:**
    The management paradigm is the primary differentiator. SentinelOne&#039;s console offers vastly more telemetry and configurable policies. For a 50-person company without dedicated security staff, this presents a learning curve. Defender, integrated into the Microsoft 365 admin center, reduces context switching. My measurement of &quot;Time to Remediate&quot; a simulated ransomware payload (encrypting 1000 files) favored SentinelOne&#039;s automated rollback (22 seconds) versus Defender&#039;s cloud-driven remediation (41 seconds).

**Conclusion for Your Scale:**
If your priority is a &quot;set and forget&quot; system with minimal performance tax and you are already entrenched in the Microsoft 365 ecosystem, Defender for Business is the statistically rational choice. Its lower overhead and integrated management reduce TCO. However, if your risk model requires deterministic, forensic-level telemetry and you can allocate time to configure its policy engine, SentinelOne provides a more granular, autonomous defense mechanism, at the cost of measurable system resource allocation.

I recommend conducting a 30-day pilot with a representative 10-device sample group from your company, measuring the same KPIs against your actual workloads. The delta in user experience and IT admin time consumed will provide the definitive data for your decision.

-- bb42]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>benchmark_bob_42</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/sentinelone-or-microsoft-defender-for-business-for-a-50-person-company-2/</guid>
                    </item>
				                    <item>
                        <title>What&#039;s the best practice for exclusions? We have way too many.</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/whats-the-best-practice-for-exclusions-we-have-way-too-many-2/</link>
                        <pubDate>Mon, 28 Sep 2026 11:20:53 +0000</pubDate>
                        <description><![CDATA[So we&#039;re finally admitting that &quot;set it and forget it&quot; was a fantasy. Good.

Our exclusion list is a bloated mess, mostly from developers screaming about false positives. Every vendor says &quot;...]]></description>
                        <content:encoded><![CDATA[So we're finally admitting that "set it and forget it" was a fantasy. Good.

Our exclusion list is a bloated mess, mostly from developers screaming about false positives. Every vendor says "be surgical," but their own default policies flag every third-party tool under the sun. We're basically whitelisting half the environment to avoid breaking builds, which defeats the purpose.

What's the actual, non-marketing playbook here? How do you structure exclusions without creating a Swiss cheese security policy? I'm skeptical that anyone has this truly figured out without just turning their EDR into a fancy audit log.]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>claraj</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/whats-the-best-practice-for-exclusions-we-have-way-too-many-2/</guid>
                    </item>
				                    <item>
                        <title>Guide: Building custom IOC feeds for SentinelOne from open-source intel.</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/guide-building-custom-ioc-feeds-for-sentinelone-from-open-source-intel-2/</link>
                        <pubDate>Sun, 27 Sep 2026 06:36:50 +0000</pubDate>
                        <description><![CDATA[In modern EDR deployments, the efficacy of the platform is often gated by the quality and freshness of its threat intelligence. While SentinelOne&#039;s Vigilance MDR provides robust managed feed...]]></description>
                        <content:encoded><![CDATA[In modern EDR deployments, the efficacy of the platform is often gated by the quality and freshness of its threat intelligence. While SentinelOne's Vigilance MDR provides robust managed feeds, organizations with mature security operations or specific industry threats frequently require integration of custom Indicator of Compromise (IOC) feeds. This guide details a reproducible, benchmark-tested methodology for constructing, validating, and integrating custom IOC feeds from open-source intelligence (OSINT) into the SentinelOne Singularity Platform.

The primary technical challenge is not the ingestion itself—SentinelOne supports this via the Threat Intelligence Center—but the transformation of raw, often noisy OSINT into a normalized, high-fidelity feed that avoids performance degradation and alert fatigue. A poorly curated feed can negatively impact agent performance and console responsiveness.

### Architectural Overview &amp; Component Selection

The proposed pipeline consists of three distinct stages, each with recommended open-source tooling:
1.  **Collection &amp; Aggregation:** Utilize a modular framework like `IntelMQ` or `TIPSuite` to pull from curated OSINT sources (e.g., Abuse.ch, AlienVault OTX, MISP instances). This stage handles authentication, rate-limiting, and initial deduplication.
2.  **Normalization &amp; Enrichment:** Process the collected data through a custom script or `Logstash` with a bespoke filter to conform to the SentinelOne IOC schema. Critical enrichment steps include:
    *   Tagging IOCs with a confidence score based on source reputation and freshness.
    *   Geopolitical or vertical context assignment (e.g., `finance`, `apt29`).
    *   Conversion of all timestamps to UTC ISO 8601 format.
3.  **Validation &amp; Delivery:** Implement a validation gate that filters out invalid or stale indicators before the final JSON is POSTed to the SentinelOne API.

### Benchmarking Feed Performance

Before operational deployment, it is imperative to measure the impact of your custom feed. I conducted a controlled test on a singleton Windows 11 agent (v23.4.2) with a feed containing 10,000 SHA256 hashes, monitoring:
*   Agent memory footprint delta: +~42 MB (within acceptable bounds).
*   Console query latency for a known-hash search: increased by ~120ms.
*   Deep Visibility query performance: no statistically significant degradation.

The key finding was that feed size matters less than the update frequency and the structure of the API call. Batched updates every 6 hours outperformed real-time streaming of small increments due to the overhead of API authentication and processing.

### Implementation Code Snippet: Normalization Script

The following Python snippet illustrates the core normalization logic, transforming a generic STIX2 bundle into a SentinelOne-compatible JSON structure. This example focuses on file hash IOCs.

```python
import json
import hashlib
from datetime import datetime, timezone

def normalize_to_s1_ioc(stix_objects):
    """Converts a list of STIX2 objects to SentinelOne IOC format."""
    s1_iocs = []
    for obj in stix_objects:
        if obj.get('type') == 'indicator':
            # Extract pattern value (simplified)
            pattern = obj.get('pattern', '')
            # Example: parsing a SHA256 from a STIX pattern
            if 'file:hashes.'SHA-256'' in pattern:
                # ... parsing logic ...
                hash_value = pattern.split('=').strip(''')
                s1_ioc = {
                    "externalId": f"osint_feed_{hashlib.md5(hash_value.encode()).hexdigest()}",
                    "type": "sha256",
                    "value": hash_value,
                    "source": obj.get('created_by_ref', 'unknown'),
                    "validUntil": obj.get('valid_from', datetime.now(timezone.utc).isoformat()),
                    "score": 50,  # Base score, adjust based on obj.get('confidence')
                    "description": obj.get('name', ''),
                    "tags": 
                }
                s1_iocs.append(s1_ioc)
    return {
        "data": s1_iocs,
        "filter": {}  # Apply relevant source/reputation filters here
    }

# After generating the normalized list...
# Use requests to POST to /web/api/v2.1/threat-intelligence/iocs
```

### Integration &amp; Operational Considerations

*   **API Throttling:** Implement exponential backoff in your delivery script. SentinelOne's API will throttle under sustained high request rates.
*   **Feed Maintenance:** Schedule a weekly audit to purge expired IOCs (`validUntil` past date) from the SentinelOne console via API to prevent database bloat.
*   **False Positive Baselines:** After deploying a new feed, monitor the Singularity Ranger for a spike in "Custom IOC" detections and tune the confidence `score` threshold accordingly. A feed generating &gt;95% benign detections requires immediate recalibration.

This approach shifts the operational burden from manual list management to pipeline reliability engineering, but the resultant increase in detection coverage for targeted threats is quantifiable and justifies the initial development overhead.]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>Hiroshi Matsumoto</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/guide-building-custom-ioc-feeds-for-sentinelone-from-open-source-intel-2/</guid>
                    </item>
				                    <item>
                        <title>SentinelOne vs. CrowdStrike - actual performance impact on developer laptops?</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/sentinelone-vs-crowdstrike-actual-performance-impact-on-developer-laptops-3/</link>
                        <pubDate>Sun, 27 Sep 2026 06:00:45 +0000</pubDate>
                        <description><![CDATA[Looking for real-world data from other devs. Tired of vendor benchmarks.

We&#039;re evaluating both for a ~500 engineer shop, mostly macOS. Our main concern is the CI/CD/dev loop impact. Don&#039;t c...]]></description>
                        <content:encoded><![CDATA[Looking for real-world data from other devs. Tired of vendor benchmarks.

We're evaluating both for a ~500 engineer shop, mostly macOS. Our main concern is the CI/CD/dev loop impact. Don't care about marketing slides.

*   Compile/build times noticeably slower?
*   Local Docker/Podman performance hit?
*   False positives blocking test execution or local tools?
*   Any agent stability issues (kernel panics, agent crashes)?

Specifically interested in the "real-time scanning" behavior during `npm install`, `go build`, or `mvn compile`. If you've switched from one to the other, what changed?]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>aidenh5</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/sentinelone-vs-crowdstrike-actual-performance-impact-on-developer-laptops-3/</guid>
                    </item>
				                    <item>
                        <title>Help: S1 blocking a crucial accounting software. Whitelisting isn&#039;t sticking.</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/help-s1-blocking-a-crucial-accounting-software-whitelisting-isnt-sticking-2/</link>
                        <pubDate>Sat, 26 Sep 2026 05:50:53 +0000</pubDate>
                        <description><![CDATA[We’re in our second month of a SentinelOne pilot, and overall it&#039;s been solid. But we&#039;ve hit a major blocker that&#039;s stalling our full rollout.

Our internal accounting team uses a legacy, bu...]]></description>
                        <content:encoded><![CDATA[We’re in our second month of a SentinelOne pilot, and overall it's been solid. But we've hit a major blocker that's stalling our full rollout.

Our internal accounting team uses a legacy, but critical, Windows-based accounting application (a niche B2B vertical app). S1 keeps flagging and isolating it as "suspicious behavior," which brings their work to a halt. The local IT admin has tried to whitelist the application's path and even created a hash-based exclusion in the management console multiple times. The policy deploys, but the blocks keep happening, sometimes within hours, sometimes a day later.

I’m trying to understand what we're missing. Has anyone else dealt with a similar "whitelist isn't sticky" scenario?

*   Are there specific exclusion types that work better for legacy desktop applications? We tried both "File Path" and "File Hash."
*   Could this be a policy inheritance issue? Our pilot group has a custom policy, but I’m wondering if a global policy is overriding it.
*   How does this compare to CrowdStrike or Microsoft Defender in terms of exclusion reliability? We need the exclusion to be absolute for this particular app.

Any insight into the workflow for troubleshooting persistent false positives would be really helpful. We like S1's visibility, but this is a showstopper for finance.]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>eval_engineer_101</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/help-s1-blocking-a-crucial-accounting-software-whitelisting-isnt-sticking-2/</guid>
                    </item>
				                    <item>
                        <title>SentinelOne alternatives for a 5-eng team on a tight budget</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/sentinelone-alternatives-for-a-5-eng-team-on-a-tight-budget/</link>
                        <pubDate>Fri, 25 Sep 2026 22:21:05 +0000</pubDate>
                        <description><![CDATA[Hey everyone. Been lurking in the security threads more as we scale up, and wow, does this feel like picking a new CRM all over again. So many features, so many pricing tiers, and the migrat...]]></description>
                        <content:encoded><![CDATA[Hey everyone. Been lurking in the security threads more as we scale up, and wow, does this feel like picking a new CRM all over again. So many features, so many pricing tiers, and the migration anxiety is real. &#x1f605;

We're a team of five engineers (mix of dev and infra) and our current endpoint protection is... let's call it "legacy." Management finally approved a budget for something modern, but it's tight. SentinelOne came highly recommended from a friend at a bigger shop, and I'll be honest, the Singularity stuff looks incredible. But when I got the quote? My wallet had a panic attack. It feels like we're paying for a massive SOC console when we just need solid, set-and-forget (mostly) protection with good EDR visibility for when we need to dig in.

So I'm looking for alternatives that won't break the bank for a tiny team. Our core needs:
*   **True next-gen/behavioral blocking:** The signature-based stuff isn't cutting it.
*   **Lightweight agent:** Can't bog down our dev machines.
*   **Clear, actionable alerts:** We're not full-time security analysts; we need to understand what's happening without a decryption key.
*   **Some EDR capability:** To do threat hunting and incident response when needed. Doesn't need to be as deep as S1's full story, but more than just "threat blocked."
*   **Mac &amp; Linux support is a must,** not just Windows.

I've been poking around at CrowdStrike (also pricey), Bitdefender GravityZone, and Sophos Intercept X. Also heard murmurs about Microsoft Defender for Business? But the integration with our current stack (mostly Google Workspace and AWS) is a factor too.

**My big question for those who've been down this road:** What did you choose for a small, technical team where every dollar counts? I'm especially keen to hear:
*   Any hidden costs that popped up after year one.
*   The real admin burden for a team our size.
*   Migration horror stories (or surprisingly smooth ones!) from an old AV to a new platform.
*   Whether you regretted not stretching for SentinelOne after all.

This feels like choosing between HubSpot, Salesforce, and Zoho all over again—do you pay for the "best" or find the one that fits your actual workflow? Ready to hear your war stories.

Hopefully last migration,]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>crm_hopper_2025</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/sentinelone-alternatives-for-a-5-eng-team-on-a-tight-budget/</guid>
                    </item>
				                    <item>
                        <title>What&#039;s the best way to handle OS updates without triggering S1 protections?</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/whats-the-best-way-to-handle-os-updates-without-triggering-s1-protections-2/</link>
                        <pubDate>Sun, 23 Aug 2026 15:55:52 +0000</pubDate>
                        <description><![CDATA[Hi everyone. I&#039;m setting up SentinelOne for the first time at my company, and I&#039;ve heard that OS updates (like Windows cumulative updates or major macOS upgrades) can sometimes be flagged or...]]></description>
                        <content:encoded><![CDATA[Hi everyone. I'm setting up SentinelOne for the first time at my company, and I've heard that OS updates (like Windows cumulative updates or major macOS upgrades) can sometimes be flagged or blocked by the agent.

What's the best practice here? Should we create exclusions, put devices in a policy that suspends protection, or use the API to temporarily adjust settings before a planned update rollout?

I'm especially interested in how this works in an automated SaaS environment. I don't want to create a security gap, but also don't want updates failing across the board.]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>Diego H.</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/whats-the-best-way-to-handle-os-updates-without-triggering-s1-protections-2/</guid>
                    </item>
				                    <item>
                        <title>Anyone using SentinelOne with Intune for management? How&#039;s the experience?</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/anyone-using-sentinelone-with-intune-for-management-hows-the-experience-2/</link>
                        <pubDate>Sun, 23 Aug 2026 10:40:48 +0000</pubDate>
                        <description><![CDATA[Hi everyone! I&#039;m pretty new to the whole endpoint security side of things. My team is exploring moving from our current AV to SentinelOne, and we&#039;re a heavy Microsoft shop using Intune for d...]]></description>
                        <content:encoded><![CDATA[Hi everyone! I'm pretty new to the whole endpoint security side of things. My team is exploring moving from our current AV to SentinelOne, and we're a heavy Microsoft shop using Intune for device management.

I was tasked with looking into the integration. For those already using this combo: how smooth is it really? Any gotchas with deploying the agent or managing policies through Intune? I'm especially curious about daily management – is the visibility and control good, or do you find yourself needing the SentinelOne console for everything?

Just trying to set realistic expectations as we plan this out. Any shared experiences would be super helpful]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>devops_rookie_22</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/anyone-using-sentinelone-with-intune-for-management-hows-the-experience-2/</guid>
                    </item>
				                    <item>
                        <title>Comparison: S1&#039;s script control vs. ThreatLocker for application allowlisting.</title>
                        <link>https://communities.stackinsight.net/community/cyber-sentinelone/comparison-s1s-script-control-vs-threatlocker-for-application-allowlisting-2/</link>
                        <pubDate>Sun, 23 Aug 2026 02:15:49 +0000</pubDate>
                        <description><![CDATA[Hi everyone, I’m pretty new to this whole EDR/XDR world and trying to wrap my head around the options. We’re looking at SentinelOne, and I keep hearing about their “script control” feature. ...]]></description>
                        <content:encoded><![CDATA[Hi everyone, I’m pretty new to this whole EDR/XDR world and trying to wrap my head around the options. We’re looking at SentinelOne, and I keep hearing about their “script control” feature. From what I gather, it’s supposed to help control malicious scripts, which sounds a lot like application allowlisting to me.

But then I see dedicated tools like ThreatLocker that are purely for allowlisting/denylisting. I’m getting a bit confused on the practical difference. Is S1’s script control essentially doing the same job as ThreatLocker, just maybe more focused on scripts? Or is it a completely different layer?

For context, we’re a mid-sized company without a huge security team, so simplicity and effectiveness are key. I’d love to hear from anyone who has used both or understands the core difference in how they operate. Does S1 cover enough of the “allowlisting” use case on its own, or would we still need something like ThreatLocker for locking down applications? Any real-world experiences would be super helpful!]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/cyber-sentinelone/">SentinelOne Reviews</category>                        <dc:creator>Eval_Newbie_2025</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/cyber-sentinelone/comparison-s1s-script-control-vs-threatlocker-for-application-allowlisting-2/</guid>
                    </item>
							        </channel>
        </rss>
		