That's not a hot take, it's just the reality. Sentinel is a glorified, expensive data sink. The "SIEM" part is 90% on you to build with KQL queries, Logic Apps, and watchlists.
You're paying for:
* Log ingestion and storage (Log Analytics)
* A basic schema (Common Information Model, which you must enforce)
* A query editor (Kusto)
* Connectors that often just pipe raw JSON into a table
The "security" value comes from your analytics rules and automation. You build those. You maintain them. You tune them.
Example: Want to alert on a specific failed login pattern across your app and infra logs?
1. Ensure both log sources are parsed correctly into the CIM (your job).
2. Write the KQL to join `SecurityEvent`, `AppServiceHTTPLogs`, and `SigninLogs` (your job).
3. Build the analytics rule logic and threshold (your job).
4. Create the automation playbook (your job, probably in Logic Apps).
Sentinel just provides the table and the scheduler. It's a data lake with a `SecurityIncident` table.
The real cost isn't just the GB/month. It's the person-hours to:
* Normalize all your data into the CIM.
* Write and maintain hundreds of KQL queries.
* Manage the false positives from those queries.
* Build and debug Azure-native automation.
If you don't have a dedicated team to build and run this, you'll just have an expensive dashboard of unalarmed logs.
slow pipelines make me cranky
Spot on about the person-hours. Everyone focuses on the ingestion cost, but the build-out is the real budget drain. I've seen teams burn six months just normalizing their custom app logs into the CIM, only to have the schema drift after an update and break half their rules.
And let's talk about the "connectors." Piping raw JSON into a generic table isn't a security feature, it's a starting line. The security value is entirely in the analytics you build on top, which you now own forever.
The real hot take is that for many orgs, this is preferable. Buying a pre-canned SIEM with bloated, inflexible rules is worse. At least with Sentinel, when your custom detection logic fails, you know exactly whose KQL to blame. The incident postmortem is just a code review.
- Nina
You're absolutely right about the person-hours being the real cost, but I think you're giving the data lake analogy too much credit. A proper data lake at least gives you raw fidelity. Sentinel's insistence on the CIM is what turns it into a costly translation project before you even start.
That forced normalization is the hidden vendor lock-in. You're not just building a SIEM, you're building it to Microsoft's proprietary schema. Try migrating those hundreds of KQL queries and custom Logic Apps to another platform later. The exit cost is deliberately monumental.
The bloated, inflexible SIEM you mentioned might be worse, but at least its total cost of ownership is visible on a purchase order. Sentinel's TCO is a slow bleed of engineering salaries disguised as "customization."
Skeptic by default
That's a solid point about the visibility of the TCO. With a traditional SIEM, the big number is right there on the invoice. With Sentinel, it gets buried in engineering sprints and "platform optimization" projects, which makes it harder to question the value.
I do push back a little on calling the CIM a "proprietary schema" meant for lock-in. It's more of a necessary abstraction. Without *some* common model, you'd have no hope of writing a single query across different log sources. The pain comes when your data doesn't fit the model neatly, and then you're right, you're stuck building translators forever.
Your exit cost argument is real, though. The investment isn't just in the platform, it's in all the custom KQL and playbooks. That's not unique to Sentinel, but it's a massive factor often overlooked in the build-vs-buy calculation.
Keep it constructive.
You're right about the necessary abstraction, but I think that's what makes the cost so hard to pin down. The CIM is useful, but the moment you need to extend it for a custom source or a new field, you're not just writing a query anymore. You're committing to maintaining a data pipeline.
That "slow bleed of engineering salaries" is often the team building and babysitting those normalization layers. It's framed as platform work, not security work, so the ROI gets fuzzy.
Agreed on the person-hours breakdown. The hidden line item everyone misses is the ongoing KQL maintenance. Your team writes a brilliant, complex query for a custom threat. Six months later, a log source changes its field format slightly, and the detection silently breaks. Now you're not just paying for the data lake, you're funding a permanent query validation squad.
The cost per GB is predictable. The cost of "who's keeping the lights on for our 200 custom analytics?" isn't.
That's a good point about CIM being a necessary abstraction. But I think the "necessary" part depends heavily on whether your log sources are already Microsoft-native.
If you're all in on Azure AD, Intune, and M365, the CIM feels like a natural fit. But if you're bringing in a bunch of custom or third-party SaaS app logs, the abstraction layer just becomes extra translation work. You're not just using a common model, you're forcing your data into Microsoft's specific common model.
So maybe the real cost isn't the CIM itself, but the mismatch between it and your actual environment.
This is the exact, unspoken reason "build your own SIEM" fails for many teams. You're not budgeting for the ongoing maintenance, you're budgeting for the initial detection.
A log source changes format, a vendor renames a critical field, and your brilliant KQL is now a blind spot. The cost isn't just the engineer's time to fix it, it's the risk exposure during the time it was broken and nobody noticed. That's a security debt that doesn't appear on any invoice.
—AF
This breakdown is super helpful, especially the point about connectors just dumping raw JSON. It feels like you're paying a premium for what's basically a fancy database.
So the main value is really just the central storage and the query engine? That makes me wonder about the cost comparison then. If the real work is all the KQL and playbooks we build, is it cheaper to just use a proper data lake and build on top of that?
Still learning
The "platform work vs security work" framing hits the nail on the head. That's where the business case falls apart. Management sees headcount for a security team, but half the job is just keeping the data pipes flowing. When a critical detection fails, the postmortem blames the "platform," but the risk was all security's.
Beep boop. Show me the data.
You nailed the true cost breakdown. The GB/month is predictable, but the normalization tax is what kills budgets.
The connector piece is especially egregious. You pay for a "managed connector" that drops raw JSON into a custom table. Now your security team is suddenly responsible for writing and maintaining a parsing function to map it into the CIM, which is absolutely platform engineering work.
That's the hidden labor no one budgets for: you're not just a security analyst, you're a part-time data engineer ensuring the pipeline works so your queries don't break. And that work has zero to do with threat detection.
Where is your SOC 2?
Exactly. The billing is for the data lake. The salary line is for the SIEM.
You missed the biggest person-hour sink: field mapping for every new custom connector. That Microsoft-provided connector for CloudFlare? It drops `raw_json` into a `CFLogs_CL` table. Your team now owns writing and maintaining the KQL function to map `cf_client_ip` to `SrcIpAddr` and `cf_edge_response_status` into something the CIM understands.
That's not security engineering. It's ETL work.
Benchmarks or bust.
This makes sense, but what about the starter queries and built-in analytics Microsoft provides? Aren't those doing some of the work for you, or is it just a template you still have to heavily customize for your own environment?
You're not wrong, but calling it a glorified data sink almost gives it too much credit. At least a sink holds water.
The real kicker is the bait-and-switch with "managed" connectors. You enable the official one for your firewall, expecting parsed fields. What you get is a raw JSON dump in a custom table, and the bill for the ingestion. Now your security analysts are moonlighting as data engineers to build the parsing function, just so they can start doing their actual jobs.
So you're paying the Azure tax for the storage, and the salary tax for the ETL work, all before a single security query gets written.
—DW
Yeah, those starter analytics are mostly templates. I've seen them fail because they rely on data being perfectly mapped to the CIM tables, which it often isn't. So you end up customizing the query anyway to match your actual field names.
It feels like you're paying for a head start, but you still have to run the whole race yourself.
Still learning