Category: Community Q&A

  • Helpdesk Impersonation Defense Requires More Than Training

    Helpdesk Impersonation Defense Requires More Than Training

    The hardest part of defending against helpdesk impersonation is that attackers can sound like genuine technical support. When legitimate requests and fake support requests appear in the same messenger, over the phone, or through a remote-access screen, an organization’s control lines can collapse if users miss a warning sign. The original article also acknowledges the limitation that some users will overlook danger signals.

    There has recently been growing awareness that helpdesk impersonation attacks are targeting organizations of various sizes. The original author mentions an approach that combines user education with detection of unauthorized RMM installations and asks other MSPs for additional defenses. The key to defending against helpdesk impersonation is not relying on education alone to create a perfect human layer of protection.

    Design Education as a “Pause and Verify When Something Seems Suspicious” Procedure

    Rather than packing educational materials with many signs of impersonation, training should teach users to verify requests for remote access or RMM installation through the organization’s official support channels instead of immediately rejecting or approving them. The process should be designed so that a requester’s name cannot be used as the authentication method, even if it matches that of a legitimate employee, and so that users also check the official ticket to which they are already connected.

    Connect Unauthorized RMM Detection to Installation Artifacts and Runtime State

    Environmental controls should compare the list of approved remote management tools with actual installations and check whether processes, services, or executable files associated with unapproved tools are present. Detecting tool names alone can miss obfuscated filenames, so it is useful to collect asset identification information, installation paths, signature information, and service status together.

    You can create a workflow that uses PowerShell to investigate the current runtime state and reviews relevant records in Windows Event Viewer. The following code is a conceptual example of process and service information that can be collected before an investigation, rather than a complete detector for identifying a specific RMM.

    ※ The following configuration and code are conceptual simulated examples to aid understanding and are not official specifications.

    Get-CimInstance Win32_Process |`
     Select-Object Name, ExecutablePath, CommandLine
    
    Get-CimInstance Win32_Service |`
     Select-Object Name, State, PathName

    The collected results can be passed to a security information and event management tool or an endpoint detection and response tool so they can be reviewed together on alert and asset screens. The key is connecting the detection rules themselves to validation data such as the approved list, owner, installation date, and responsible team member. If alerts continue to appear for a legitimate RMM, both the security team and the helpdesk should reference the same asset list.

    Unify Reporting, Verification, and Response Around a Single Asset

    A user report should not end with the statement that someone received an unusual request. It should also record the channel through which the request arrived, the affected user, the time of occurrence, whether remote access was approved, and the tool for which installation was requested. The security employee can then check the asset for installation and execution artifacts, while the helpdesk can look up whether the tool is approved and who approved it.

    If the suspicious tool is confirmed, remote access permissions and stored credentials should be revoked and invalidated first, while the relevant installation files and persistence artifacts should be preserved until the root-cause analysis is complete. Applying the same warning and verification procedures to both users and administrators can help reduce recurrence and confusion.

    Operational Costs Arise from the Verification Loop, Not Just the Tools

    After deployment, review training comprehension, accessibility of the reporting menu, accuracy in identifying legitimate RMM tools, time spent handling false positives, and cases of missed detection. Expanding detection coverage increases the cost of handling alerts, while narrowing it makes it easier to miss altered installation signatures. The most common antipattern is to repeat education campaigns without measuring the accessibility of the actual reporting workflow, then manually search for approval status from scratch every time a detection alert appears.

    Practical discussion of this issue is continuing in an r/msp discussion on responding to helpdesk impersonation attacks.

    What You Can Do Now

    • Reflect the procedure for verifying official support channels and remote-access or RMM installation requests in both training materials and helpdesk automated responses.
    • Populate the approved RMM list with tool names, owners, responsible teams, and identification information, and make it available for reference across the organization.
    • Use PowerShell and Event Viewer to collect process and service records for each asset and test the framework for investigating unauthorized tools.
    • Add fields for the affected asset, request channel, approval status, and installation tool requested to the reporting form.
    • Classify alerts for legitimate tools and genuinely suspicious cases, and regularly review detection accuracy and processing time.

    Source Article

    This article was prepared by checking the following source: r/msp — How are you protecting your clients from Helpdesk impersonation attacks?

  • How AI Quality Validation Protects Customers

    How AI Quality Validation Protects Customers

    When AI-generated results are criticized, it is difficult to respond immediately that errors existed before. Above all, if the error is hidden in a data-processing stage that does not appear in the code, a normal-looking interface alone cannot guarantee quality. What such an environment needs is not a halt to all AI use, but AI quality validation standards that apply before results reach customers.

    The source of the problem lies more in management structures than in an individual’s disposition. A manager did not review generated results for errors, even while using AI to develop a product from the outset, and ignored employees’ concerns out of fear that doing so might damage their standing. Processing errors that could affect customer contracts worth millions of dollars were also discussed as a possibility.

    A further problem was that the manager ran the entire project alone while describing it as the team’s progress, and no one read the reports submitted during branch reviews. In an organization like this, simply resubmitting the report is unlikely to solve the problem. If the reporting channel is not read, it is better to change validation and decision-making through separate records and approval structures.

    Preventing AI Tool Adoption from Creating a Validation Gap

    AI is a tool for increasing the volume of code written. It also increases the number of changes that must be reviewed. However, if reviewers skip validation because “the code was written by AI” or “the tests passed,” the gap between generation speed and trust only widens. Rather than rejecting management demands to use AI, organizations should design every result to pass the same approval standards, regardless of how it was generated.

    First, add AI code quality management rules to repository policies. Run the same tests and static analysis for AI-generated and human-written code in the CI/CD environment being used. Configure tools to inspect dangerous code patterns, complexity and defects, and dependencies with known vulnerabilities, and have humans directly review critical modules. Critical modules should be reviewed directly by a person, with deployments blocked whenever a test fails or an approval is missing.

    git checkout -b quality-gate/ai-result-review
    git push -u origin quality-gate/ai-result-review
    semgrep --config auto.
    dependency-check --scan./

    The commands above are a conceptual example for starting a validation workflow; the actual project configuration and available options should be adjusted to fit the repository environment. When using GitHub Actions, define pull request validation, testing, static analysis, secret detection, and dependency inspection jobs in the repository’s Actions settings, and configure deployment jobs to depend only on successful validations.

    Recording the Generation Path Through Change Records

    Recording only that an output was generated makes AI results difficult to reproduce. Change records should include the reason for the change, the tool or model used, the prompt and input conditions, the reviewer, test results, and the approver. Changes containing AI code should follow the same pull request procedure as regular changes, while large changes should be isolated on separate branches. This makes it possible to review the generated output and the conditions in place when an error is discovered.

    During operations, maintain logs for each processing stage, exceptions, performance metrics, data quality rules, customer-specific failure tracking, and alerts to monitor changes in output quality. Do not rely solely on automatically generated tests to determine actual quality; compare results with the baseline established before AI adoption to identify regressions.

    Escalating to Management When Reports Go Unread

    An error report should be written as a request for a decision, not as a one-sentence warning. Clearly distinguish a reproducible minimum example, expected and actual results, scope, potential customer impact, mitigation measures, residual risk, and the decision required. This record can also be escalated through quality, compliance, and project management channels in addition to the manager. Presenting options within the approval workflow protects the organization better than creating a public conflict.

    Pre-deployment approval procedures are also more realistic when divided according to risk and change size. Separate standard reviews, additional security reviews, and accountable-owner approval, and ensure the final approver is recorded for every error found. The document should record who recognized which risk and what decision was made, rather than assigning blame to an individual.

    Minimum Rules You Can Apply Today

    Antipatterns to avoid include accepting AI results after checking only syntax and formatting, unconditionally rejecting AI use, assigning blame without evidence, engaging in public conflict, and relying on verbal promises instead of validation procedures. The original thread, which organizes related cases and discussions, likewise identifies the core problem as a management failure in which the manager does not review AI results.

    To begin the review process, place AI results awaiting deployment into the same change review flow as regular code, and configure deployments to be blocked if testing, static analysis, or dependency inspection requirements are not met. Change records should include the generation tool, input conditions, reviewer, test results, and approver, while discovered errors should be documented with reproduction cases, impact scope, mitigation measures, and residual risk. Organizations where reports are not consumed must also establish quality, compliance, and project management channels.

    Practical Application Points

    • Coordinate with relevant teams and confirm approval paths
    • Conduct advance impact testing in an isolated environment
    • Establish a phased rollout and emergency rollback plan

    Source

    This article was prepared after consulting the following source: r/cscareerquestions — How do you deal with managers who have AI delusions?

  • Turn Cloud EOL Alerts Into Actionable Remediation Work

    Turn Cloud EOL Alerts Into Actionable Remediation Work

    The most frustrating moment in cloud operations is when an end-of-support notice lands in the inbox, but no one connects it to their team’s workloads. Assets with different lifecycles, including AI model versions, Kubernetes versions, serverless runtimes, and database engines, reach end of support simultaneously. Even when teams know what is about to expire, they still lack the answer to who must change what, and by when. Filling this gap is the essence of cloud EOL management.

    There are several ways to find notices. Service Health, AWS Health, Advisor, vendor emails, and internal scripts each provide different signals, so relying on a single source leaves gaps. The original source also asks whether these channels are used together. The real problem, however, comes after collection. Notices usually reach account or subscription owners, while the impact of an actual change falls on a specific workload team.

    Receiving a Notice Is Only the Start

    Patch management tools alone cannot solve the problem. Software dependency management tools such as Renovate and Dependabot are useful for managing library versions, but they do not automatically track service end-of-support events for managed AI models, Kubernetes versions, or serverless runtimes. Pinning a version in IaC does not guarantee safe deployment by itself. Teams must separately verify when the pinned version will reach end of support.

    Operational standards therefore cannot rely only on whether a notice was received. Each item needs to link its end-of-support schedule, affected accounts, subscriptions, and regions, actual workloads, owning team, replacement path, and response deadline. Only items that have also passed verification should be considered closed. Without such standards, more alerts make it harder for owners to decide what to address first.

    Connect Notices to Workload Owners

    The first step is to normalize notices into a common format. This means consolidating the service type, affected version, end-of-support date, original link, and collection path into a single record. The next step is to connect that record to actual deployment targets using identifiers for accounts, subscriptions, regions, services, and resources. What is needed here is not a static owner list, but rules for keeping ownership information current and a procedure for handling broken connections.

    In practice, it is effective to combine the organization’s asset discovery system with a CMDB or ownership metadata. If organizational structure and deployment metadata remain in separate systems, teams should not designate either as the sole source of truth; instead, they should reconcile them regularly. Notices that cannot be connected should be separated as unassigned items and resolved with the responsible organization rather than assigning owners by guesswork.

    Use Terraform and CI as Final Safeguards

    IaC and CI checks can serve as effective supplemental guardrails. Checking Terraform-pinned versions and deployment pipelines for end-of-support targets can reveal issues before operational rollout begins. However, these checks are safeguards for examining actual deployment configurations; they cannot replace the collection of notices across every account and subscription or the mapping of notices to owners.

    ※ Note: The following configuration is a conceptual simulation example and does not represent an official specification. Actual policies should reflect each organization’s version sources and approval procedures.

    eol_policy:
     reject_unmapped_notice: true
     require_owner: true
     require_replacement_plan: true
     block_deployment_after_end_of_support: true

    Check results should retain more than a simple list of failures. They should also store the deployment targets using the affected version, owning team, candidate replacement versions, and a link to the CI run. Only then can a policy violation become actionable work.

    Manage Status from Receipt Through Regression Testing

    An operational workflow is easier to interpret when it consists of the following statuses. First, record the notice as Received, then use Impact Analysis to confirm actual usage and scope. During the Planning stage, finalize the owning team and response deadline, and apply the new version or alternative architecture during the Replacement stage. Only after traffic migration and regression testing have been confirmed in the final Verification stage should the item move to Closed.

    This status model can be implemented in business systems. Rather than building a complex dedicated platform from the start, it is more realistic to begin with a system capable of connecting notices, assets, owners, and work records. Automation should initially focus on collection, deduplication, suggesting potential owners, and issuing deadline warnings, while replacement decisions should remain with the responsible teams.

    Practical limitations are also clear. If ownership information is neglected, automation cannot route work to the correct owner. Querying multiple accounts and subscriptions increases access requirements and costs, while differences in notice formats across vendors require ongoing maintenance of collection rules. The most dangerous operational approach is to monitor only subscription-owner email or deliver every notice with the same priority. A version-tracking spreadsheet also fails to become an execution-management tool unless it connects owners, response status, and verification results.

    Maturing cloud EOL management requires treating the list of notices as something other than the goal.

    The original discussion on the same topic also asks how notices are found, how they are routed to responsible teams, and whether IaC and CI checks are used.

    In practice, teams can begin by collecting recent end-of-support notices from Service Health, AWS Health, Advisor, and vendor emails, then organizing them into a common list. Each notice should include the account, subscription, region, affected version, end-of-support date, and original link. Teams can then compare the organization’s asset discovery system with its CMDB and deployment metadata to confirm actual workload usage and identify the owning team. Unassigned notices should be resolved with the responsible organization, while end-of-support checks can be added to Terraform-pinned versions and CI pipelines to test pre-deployment blocking and replacement-version validation.

    Practical Implementation Points

    • Confirm coordination and approval paths with relevant teams
    • Conduct advance impact testing in an isolated environment
    • Establish a phased rollout and emergency rollback plan

    Original Source

    This article was written after reviewing the following source: r/devops — How does your team track everything that’s about to be retired in your cloud?

  • Too Many JavaScript CVEs? Verify Real Artifact Risk

    Too Many JavaScript CVEs? Verify Real Artifact Risk

    JavaScript vulnerability management does not end with generating a dependency list. Generating an SBOM with Syft in CI and uploading it to Dependency-Track is useful for obtaining a reproducible dependency list, but whether that list matches the code actually included in a service remains a separate issue. A lockfile contains many packages, while only some make it into the final bundle, and determining whether the vulnerable code paths are even reachable requires yet another assessment.

    Therefore, artifact vulnerability verification should be the next step after generating an SBOM. Mixing potential vulnerabilities, build-stage vulnerabilities, and direct risks in the final artifact under the same rating can inflate CVE counts because of development packages while obscuring the actual remediation order. The solution is not to abandon lockfile scanning, but to explicitly manage the differences between the lockfile and deployed artifacts.

    Why the Full Lockfile Becomes an Excessive Candidate List

    A lockfile records packages that never enter the final browser code, including development servers, bundlers, and test tools. For an SPA, excluding devDependencies can mitigate this to some extent, but in a Laravel structure, NPM packages are placed in devDependencies, making it difficult to describe the server-side build configuration based on that classification alone. Therefore, the first question is not the category name, but whether the package remains in the deployed artifact.

    The same problem appears in a original thread about scanning JavaScript CVEs. Its central question is how to distinguish packages in the lockfile from packages included in the bundle, and it also presents an experience suggesting that generating sourcemaps can significantly reduce the results. Sourcemaps are useful clues, but they are not verification results that can be included with public assets.

    Do Not Mix Two SBOMs into One Result

    The recommended pipeline is to scan source dependencies and deployed artifacts separately. At the source stage, generate a lockfile-based SBOM to manage missing dependencies and update candidates. At the deployment stage, rescan the built public assets or final container image. In Dependency-Track, do not treat both results as identical evidence for the same asset; preserve the difference between the potential source list and the deployed inclusion list as a separate stage.

    The source directory and build output can be managed as separate artifacts.

    ※ Note: The following is a conceptual simulation example (Illustrative Example, not official spec)

    The following commands are a basic form of generating package lists for the working directory and build output.

    npm ci
    npm run build
    syft dir:. -o cyclonedx-json > sbom-source.json
    syft dir:public/build -o cyclonedx-json > sbom-build.json
    

    Actual paths and build scripts should be adapted to the project structure. For a Laravel application, separately verify whether NPM dependencies are included in the final build configuration. The build output and files included in the deployment image should serve as the basis, rather than the classification in package.json.

    Compare Inclusion in Bundles and Deployment Images

    For typical frontend assets, inspect the final app.js and, if necessary, analyze the sourcemap generated during the build to compare bundle inclusion. Keep sourcemaps as analysis artifacts and exclude them from deployment images. The criterion should be the code paths that remain in the final bundle, not the number of lockfile entries.

    Deployment verification must go one step further. Scanning the container image created in CI as-is makes it possible to confirm the separation between build tools and runtime files. Items in the artifact vulnerability verification results that are included in operational assets should receive a high remediation priority, while development, build-stage, and reproducibility-verification items should be managed under a separate policy.

    Can You Trust Sourcemaps Alone?

    Sourcemaps are important clues when comparing the lockfile with the bundle, but they do not prove inclusion in the deployed artifact by themselves. Therefore, use sourcemaps as supporting evidence and verify the files inside the deployment image and reachable code paths together.

    Unconditionally upgrading every package because the CVE count is low is also risky. Updates should be decided only after checking whether the vulnerable package is included in the deployed artifact, whether its execution path is reachable, and whether the code is used. This approach preserves lockfile scanning while avoiding indiscriminate changes intended merely to reduce CVE counts.

    In practice, store the lockfile SBOM as the list of potential source dependencies and identify the location of public assets after the build. Generate SBOMs for the source and build outputs separately with Syft, compare their differences, and identify runtime packages separately in the final container image. Add a CI rule that checks deployment inclusion and execution paths whenever an upgrade alert is received.

    Practical Implementation Points

    • Confirm coordination and approval paths with relevant teams
    • Conduct advance impact testing in an isolated environment
    • Establish a phased rollout and emergency rollback plan

    Original Source

    This article was written after reviewing the following original source: r/devops — How do I actually scan for CVEs for Javascript?

  • How to Verify and Work Around the KB5127648 PC Warning

    How to Verify and Work Around the KB5127648 PC Warning

    In production environments, if users see a warning stating that someone else is using their PC whenever they request a restart or shutdown after a Windows update, administrators should not immediately assume that the message itself is the cause. Instead, they need to check separately whether this is an update issue and examine the state of user sessions. This case occurred on a laptop running Windows 11 24H2 Enterprise that had received this month’s cumulative update, even though no other user was actually connected.

    The warning reads, “Someone else is still using this PC,” followed by an explanation that restarting could damage another user’s unsaved work. Because this can instead cause anxiety and interrupt business operations, administrators must document whether the update was installed and under what conditions the warning appeared before deciding whether to temporarily roll back the update.

    The original thread reported that uninstalling KB5127648 made the message disappear, while reinstalling it caused the warning to return. Although this correlation alone cannot pinpoint the exact defect inside Windows, it provides sufficient grounds to examine the update installation state before considering user error or a security breach.

    Separate the Update Issue From the Warning Message

    The key to this issue is determining whether the message displayed on the screen matches the actual session state. The organization confirmed that no other users were connected, the problem was reproduced on an affected PC, and the warning disappeared and returned following the removal and reinstallation of the update. Administrators therefore should not automatically interpret the warning as a safety signal and terminate user sessions. Instead, they should compare the update states of affected and unaffected PCs under the same conditions.

    First, check the Windows 11 Enterprise build and whether KB5127648 is installed on both the affected and unaffected PCs. You can view the list of installed updates by running the following command in an elevated PowerShell window.

    Get-HotFix | Sort-Object InstalledOn -Descending

    The command results will not identify the cause of the warning on their own. Compare PCs on which KB5127648 appears with those where it does not, and save the results from before and after the update separately so they can be compared with subsequent reproduction attempts. Install, remove, and reinstall the update on test equipment or during an approved maintenance window, taking the organization’s change-management procedures and service-stability requirements into account.

    Step-by-Step Verification Procedure

    First, with KB5127648 installed, perform a restart and a shutdown separately, recording the warning message, its occurrence time, and whether each operation completes normally. Second, remove the update and repeat the same procedure on the same PC. Third, if possible, reinstall the update and determine whether the warning reappears. These comparison records provide a clearer basis for assessing causality than screenshots supplied by users.

    The scope of the verification should also be expanded. If the same results appear across multiple users and PCs, the organization gains stronger grounds to reflect the issue in its update-management practices. If the warning is limited to a single PC, separately investigate factors outside the update, such as drivers, security software, user profiles, and local administration tools. Because the original report does not identify the exact location of the underlying defect, administrators should not blame a specific component at this stage.

    When Administrators Should Roll Back the Update

    At present, the key signal is the observation that removing KB5127648 makes the warning disappear, while reinstalling it causes the message to return. If the warning appears but restarts and shutdowns complete normally with no data loss, administrators may consider temporarily rolling back the update until official resolution information becomes available. Conversely, if the organization confirms the loss of unsaved work or actual operational disruption, it should reassess its update-retention strategy at the organizational level.

    Although the original report advises administrators to tell users to ignore the warning, doing so does not mean the update defect has been resolved. It is a temporary operational decision intended to reduce inconvenience. Administrators should separately verify that systems shut down normally after the warning is ignored, check for other errors, and confirm that saved files are unaffected. Rather than leaving the update issue to users, the safer approach is to collect status information from the administrator console and communicate the affected equipment and conditions.

    Responses to Avoid

    Administrators should not assume that another user is logged in merely because the warning appears, nor should they forcibly clear user sessions. This case confirmed that no other user was connected, and the warning itself—not the actual session information—was the problem. They should also avoid concluding that Windows files, drivers, or security software were damaged and beginning remediation solely because the warning disappeared after the update was removed.

    It is equally important not to speculate about or share nonpublic user information and session contents without evidence of a security incident. Administrators should document confirmed facts, reproduction conditions, differences from unaffected PCs, and temporary mitigation measures separately. After confirming whether an official fix is available, they can determine the organization’s next update policy. This approach turns the response into a structured verification process that reduces unnecessary confusion for both users and the organization.

    What to Do Now

    • Collect the PowerShell Get-HotFix results from affected and unaffected PCs, then compare whether KB5127648 is installed.
    • Perform a restart and a shutdown separately with KB5127648 installed, recording whether the warning appears and whether each operation completes normally.
    • On approved test equipment, repeat the same procedure after removing the update and document the before-and-after differences in the change record.
    • Reinstall the update on equipment where the issue can be reproduced, confirm whether the warning returns, and determine whether it is limited to one PC or affects multiple systems.
    • Check for lost work and additional errors, then use the change-management process to decide whether to temporarily roll back the update until an official fix is available.

    Source

    This article was prepared by reviewing the following original source: r/sysadmin — KB5127648 causing “Someone else is still using this PC” message

  • AI PR Reviews: Read Dependencies Before Filenames

    AI PR Reviews: Read Dependencies Before Filenames

    As AI coding agents begin generating multiple files at once, reviewers must change how they work. If you start reading a large PR review containing dozens of files from the top, you may see the implementation before encountering the contracts and schemas that support it. After spending considerable time, you finally understand what the change is really centered on.

    This is especially true when Git presents files by path and name order, because that order does not explain the system’s division of responsibility or execution flow. In a 20-file change produced by an agent, you may encounter utility helpers or UI components before reaching the database schema or core interface that determines actual behavior. Instead of reading more lines, reviewers should first understand which contracts and call paths those lines connect to.

    Why Alphabetical Diffs Do Not Show Structure

    A file list reflects the result of the repository directory, not the architecture. If the UI calls a service function, the service depends on an interface, and the interface requires a data model, sorting file names alone cannot reveal that direction. The moment you begin reconstructing the call graph in your head, restoring the structure takes on greater importance than the code review itself.

    This problem cannot be solved by attaching one more automation tool. Treating an agent’s description of a change as the premise of the review, or approving the final diff solely because tests pass, can allow missing dependencies to slip through. The review of a large change should focus not on the amount of implementation, but on how contracts are changing and how far their consumers and callers are affected.

    A discussion has begun on reviewing large changes produced by agents and how those changes should be reviewed. The central question is simple: In what order should a team read a 20-file diff?.

    Rearrange the File List by Contract and Call Flow

    The first step is to classify changed files by responsibility instead of arranging them in an arbitrary line-by-line sequence. Start with contracts, interfaces, and schemas, then review domain services and orchestration. Next, examine callers of changed interfaces, tests, and finally the presentation layer. This order lets you focus on high-risk dependency paths instead of reading every line at the same depth when many files are involved.

    Git’s diff commands can be used in stages to gather this information. The key is to separate the size of the change from its file list.

    git diff --stat
    git diff --name-only
    git diff --find-renames
    git diff --word-diff

    --stat shows the size of the change, --name-only lists the files under review, and --find-renames distinguishes file moves from file changes. For changes where a single line matters, such as contracts or configuration, --word-diff makes it easier to avoid missing implementation details. The results of these commands should then be rearranged into lists of contracts, schemas, callers, tests, and presentation-layer files.

    Find the Impact Range of Schemas and Interfaces

    When reading a core contract, do not judge only the implementation details. Also find the code that directly calls the interface, the code that produces messages or API responses, and the migration paths that read stored data. If an interface changes, verify whether backward compatibility could break. If the response structure changes, identify the affected consumers. If a schema changes, confirm that the migration and rollback sequence remains valid.

    In the review document, first record the entry point of the change, the changed contract, unexpected call paths, and the state involved in rollback. Group callers, consumers, and schema changes as one logical unit, but, where possible, separate contract changes, caller updates, data migrations, and behavior changes into smaller units. If the environment supports a feature flag, limit the actual reach of the change and deploy it in stages so you can narrow the cause when a regression occurs.

    Tests Are Verification Gates, Not Just a Pass/Fail Check

    In a large PR review, tests are not a ritual to run once at the end. When the change reaches a contract, add contract tests. When multiple layers are connected, add integration tests. When a schema changes, include migration and rollback validation. Tests that do not cover failure paths only demonstrate the happy path and cannot validate the branches where the real risks lie.

    Before requesting approval, record the change summary, impact range, validations performed, remaining risks, and rollback procedure. Even when tests pass, separately assess whether the contract’s intent is correct, whether all callers have been updated, and whether reverting the change leaves the data in a safe state. This allows you to treat AI-generated output as an independent target for verification rather than automatically trusting its design.

    Common Limits and Pitfalls in Practice

    Introducing dependency-focused reviews adds cost. It takes time to organize the call graph and explain relationships between files, and classification can be difficult in repositories where architectural boundaries are unclear. Automated classifications may differ from the actual call flow, so do not use a tool-generated list as the premise of the review; verify the relationships yourself.

    The most common antipatterns are judging the implementation immediately after reading files in name order, accepting the agent’s stated purpose for the change without question, and merging the final diff simply because tests pass. Dividing a large change into smaller logical units reduces the scope that can be merged at once, but contracts and callers may still be scattered across different groups. The basis for separation should be compatibility responsibility and rollback feasibility, not the number of files.

    Try This Now

    • Run git diff --stat and git diff --name-only on the current branch, recording the size of the change and the file list separately.
    • Classify the file list into contracts, schemas, services, callers, tests, and presentation-layer files.
    • Search for changed interfaces and schemas, and mark their callers, consumers, and migration paths.
    • Use git diff --find-renames to distinguish actual moves from changes, and reread contract changes with git diff --word-diff.
    • Before merging, record contract, integration, schema, failure-path tests, and the rollback procedure in the review request.

    Source

    This article was prepared after reviewing the following source: r/devops — Why are we still reviewing massive PRs in alphabetical file order?

  • Azure Sev1: Is External Support the Real Answer?

    Azure Sev1: Is External Support the Real Answer?

    Why Official Support Tickets Alone Become Insufficient

    One of the realities encountered as Azure usage scales is the declining responsiveness of official Azure support tickets. A post on r/AZURE titled “Slow response, generic answers, tickets bouncing around” recounts the experience of facing this twice in a year. Template answers keep repeating, tickets bounce between departments, and the situation of having to find the root cause internally repeats itself twice. Engineers at this stage develop the hypothesis: “If we raise the support tier, won’t it be resolved?” However, an evaluation left by an engineer with 8 years of experience is sobering. “It doesn’t matter. It’s all useless IMO” — the diagnosis is that the fundamental premise may be off before discussing tools or tiers.

    The Two Faces of Azure Sev1: Platform Impact vs. Customer Environment Operational Impact

    When the statement “No one can handle a sev1 other than the actual Microsoft engineers if it’s really a sev 1” appears in the community, it is immediately met with the counterargument “Sev1 doesn’t mean its something Microsoft can only fix”. Although the two positions appear to clash, in practice they are simply viewing the same issue from different axes. Sev1 is a label indicating priority (impact and downtime), not a certification of who can resolve it. An incident where a VPN was accidentally deleted by the operations team is also classified as Sev1, but this is an area that can be restored even without Microsoft. On the other hand, “As an Azure service itself has a Sev 1 issue” — a platform-impact outage in the Azure service itself is something only Microsoft engineers can resolve with backend permissions. Therefore, to argue for the introduction of external support, one must first label “which domain the Sev1 falls under” rather than comparing the options themselves. In practice, it is recommended to establish an operational standard of classifying on two axes immediately upon ticket ingestion: impact scope (platform vs. customer) and responsibility boundary (Microsoft vs. your own organization).

    Substantive Option Comparison: Mission Critical / Consultant / General External Support Provider / Internal Capability

    The high-quality options repeatedly mentioned in the community are essentially compressed into two paths. The first is the Microsoft Mission Critical support tier, the top-tier option layered on top of a Unified agreement. “It has a separate support queue to FTE only knowledgable engineers (same set of people for your company so they may even have historical knowledge)” — this is an evaluation that full-time dedicated engineers are fixed in a separate queue, with no quarterly rotation, so historical knowledge about the company stack accumulates. “The gang on there is top notch and they don’t get shuffled around each quarter so they get to know your stacks” — the fact that the same team is maintained is cited as the substantive value. The downside is clear. “Expensive as hell” — costs are very high, and “Unless Azure is one of your main hyper scalers, I wouldn’t recommend it” — if Azure is not a primary hyperscaler, the cost-effectiveness does not match.

    The second option is purchasing a time block from a well-known independent consultant or qualified engineer. “Actual knowledge of the platform (say like purchasing time from a respected consultant, or hiring someone qualified) is going to help you quicker than support” — deep diagnosis is possible immediately without going through the official queue. However, since it depends entirely on the consultant’s depth, operators must accept that quality variance will be large unless they have a pre-verified contact.

    Other general MSPs are evaluated almost consistently negatively by the community. Eventually, the likelihood of re-escalation to Microsoft is high, the perception is that only cost is added in the middle, and the original post’s author also expresses “every vendor we talk to sounds exactly the same”. The full context can be confirmed in the original thread (r/AZURE What are the real microsoft azure support alternatives).

    Option Resolvable Scope Response Speed Cost Key Limitation
    Mission Critical Tier All platform-impact outages Dedicated FTE fixed queue Very high Azure must be the primary hyperscaler for cost-effectiveness
    Qualified Consultant Time Block Customer environment operational outages Immediate deployment possible Hourly rate Depends on individual depth, quality variance
    General External Support Provider Limited, frequent re-escalation Additional intermediary step Medium Eventually re-routes to Microsoft
    Internal Capability Strengthening Customer environment operational outages Immediate Personnel cost Requires internal diagnostic capability

    Four Decision Axes: Dependency · Incident Frequency · Internal Capability · Budget

    Option selection is not based on a single criterion but requires simultaneous evaluation on four axes. First, whether Azure is the primary hyperscaler is the prerequisite for introducing the Mission Critical tier. Second, measure how many Sev1 incidents actually occurred over the past year. A frequency of two incidents makes it difficult to justify a high-priced tier. Third, the key question is whether there is at least one engineer internally with deep Azure knowledge. “Have engineers that can figure things out on their own” — this is what the 8-year-experienced engineer emphasized most. Fourth, confirm whether the budget structure can support external support costs indefinitely. One-off contracts and quarterly renewal structures carry the risk of knowledge loss. If even one of the four axes is weak, the combination of a consultant time block + internal champion is evaluated as a realistic alternative over a high-priced tier.

    When Raising the Support Tier Is Useless

    “Use services the way they are meant to be used” — community evaluation points out that a configuration that deviates from the intended usage pattern is the fundamental cause. “If you stray from the path you lose valuable documentation and any hope support can do something for you” — in areas where there is almost no documentation or diagnostic log, no matter how high the tier of engineer deployed, diagnosis itself becomes impossible. In other words, Azure official support operates normally only within the scope supported by intended usage patterns and documentation. The higher the proportion of usage outside the scope, the closer the value of the support tier converges to 0. In this case, the fastest solution is to revert the architecture itself to the intended pattern, not to raise the tier.

    What to Do Right Now

    • Share the operational standard of labeling “platform impact / customer environment operational impact” immediately upon Sev1 ingestion with the junior team.
    • Record the number of Sev1 occurrences and average recovery time over the past year to quantify the effect of introducing external support.
    • Review the Mission Critical tier only if Azure is the primary hyperscaler; otherwise, pre-sign a time block contract with 1–2 pre-verified consultants.
    • Check whether the current architecture is within the Well-Architected recommended pattern, identify areas outside the scope, and establish a regression plan.
    • Designate one internal champion to centralize Sev1 case records and consultant contacts.

    Reference Original

    This article was written after reviewing the following original: r/AZURE — What are the real microsoft azure support alternatives out there?

  • AI Burnout Is Structural, Not a Tool Problem: 4-Step Fix

    AI Burnout Is Structural, Not a Tool Problem: 4-Step Fix

    Even today, the hand that closes the IDE at 1 AM feels heavy. Ten to twelve hours a day, six days a week, for a year and a half. The promise that AI would make coding easier has gone somewhere, and what remains in practice is a growing list of pull requests and an ever-changing list of tools. A confession posted to r/cscareerquestions by an engineer with nine years of ML experience spread quickly. The line—pressure to “work faster and more” after the shift to AI-first/AI-native—captured the felt experience of the past period exactly. Having already gone through one round of restructuring with the next round already announced, the comment that “refusing” is not an option resonates as well. This article decomposes AI burnout not as an individual willpower issue but as a practical framework of work boundaries, tool standardization, and WIP limits.

    Why This Happens — Three Structural Causes

    ① The combination of speed pressure and layoff fear. The “AI-first” declaration is translated in practice as “faster and more.” When this is layered on top of “market anxiety with another round of restructuring already announced”, the room for individuals to refuse essentially disappears. Overtime becomes not a choice but a defensive mechanism.

    ② Tool learning costs offloaded to overtime. AI tools like Cursor, GitHub Copilot, and Continue.dev reduce productivity for days to weeks right after introduction. When that learning time is not counted as official work hours, it ends up absorbed as self-imposed overtime. The original post also states explicitly that “developers must constantly learn new AI dev tools”.

    ③ The AI version of Parkinson’s Law. Time freed up by AI is immediately filled with new work the moment it sits empty. That the original author felt “the productivity gain came not from AI but from overwork” is precisely this effect. No matter how many tools are swapped, the result is the same unless the work-volume ceiling itself is controlled.

    Step 1 — Visualize: Turn ‘Felt Busyness’ into Data

    The precondition for any fix is turning WIP and work hours into data. WakaTime runs automatically as an IDE plugin and records daily coding time by language. Clockify provides manual allocation by project and task, separating meetings, reviews, and coding into a visible ratio. RescueTime visualizes focus scores and fragmented time. Running these tools for just one week surfaces a distribution like “meetings 30% / coding 50% / notification checks 20%,” creating an objective baseline for improvement.

    Step 2 — Standardize AI Tools and Formalize Learning Time

    Constantly switching tools out of FOMO means context-switching costs erode any efficiency gains. In a team meeting, select one or two from Cursor/Copilot, and separate learning of other tools into a formal “20% slot” (weekly cap of 4 hours). The key is making the agreement with the manager explicit that “learning time is not self-development but paid work time.” If the company refuses to compensate learning time, that cost is absorbed only through personal overtime, and this asymmetry is the structural cause of AI burnout.

    Step 3 — Reduce Context Switching with WIP Limits

    Use the WIP limit column in Linear, Jira, or GitHub Projects to enforce a cap of 2–3 concurrent issues per person. When concurrent in-progress tasks exceed 5, effective coding time drops to half or less because of context-switching costs. WIP limits are not simply a cap on “open issue count” but a policy that intentionally breaks the combination of “reviewing PRs + coding + in meetings” to protect coding time. If work-queue wait time is metricized with OpenTelemetry, bottlenecks right before overtime can be detected early.

    Step 4 — Agreement on Blocking Night and Weekend Alerts

    Configure PR review bots like CodeRabbit and Sourcery, Slack, and GitHub notifications to ring only during work hours. For GitHub notifications, enable only the “Participating/Mentions” filter and switch all other repositories to “Unwatch.” Lock Slack DND from 19:00 to 09:00, and run weekend on-call voluntarily with separate compensation. Without this agreement, tool efficiency translates directly into alert fatigue, and a culture that admires “the person who replies fast” converges on notifications being always on.

    Three Anti-Patterns That Must Be Removed

    First, infinite AI tool collection. Trying a new tool every week lets the learning curve eat the efficiency gains. Lack of standardization is the most common technical trigger of overtime. Second, a culture that packages overtime as a signal of dedication. The original post’s report of 10–12 hours and six days a week is a clear signal of this culture. Third, a structure that nominally labels learning time as “self-development”. When the company refuses to compensate, that cost accumulates only as personal overtime.

    Key Takeaway

    The productivity promise of AI tools holds only under the assumption of “fixed work volume.” When an organization does not control the work scope, alert boundaries, or concurrent task count, the efficiency gained from tools is immediately absorbed into overwork. “Tool efficiency” and “work-volume control” must always move together. The answer to the question raised in the original post is not swapping tools but reaching team-level agreement on these four boundaries.

    What to Do Right Now

    • Install WakaTime: Install the IDE plugin this week and run it for 7 days to output a daily coding-time report. If overtime is not visualized, there is no baseline for improvement.
    • Agree on a standard tool: In the next team meeting, agree on one of Cursor/Copilot as the standard, and formalize any learning beyond it as a “20% slot” capped at 4 hours per week.
    • Enforce WIP limits: Enable the WIP limit column in the Linear/Jira board to cap concurrent in-progress issues at 2–3. When exceeded, force new issues to “Queued.”
    • Filter GitHub notifications: Turn on only “Participating/Mentions” and switch all other repositories to “Unwatch.” Lock Slack DND from 19:00 to 09:00.
    • Agree on learning time: In the next 1:1, formalize the agreement with the manager that “learning time = paid work time.” If refused, treat that organization as a signal that it structurally maintains AI burnout in the long run.

    Reference

    This article was prepared with reference to the following original post: r/cscareerquestions — Why am I working more if AI was supposed to make coding easier?

  • OSINT Attacks: The Exposure Gap That Phishing Drills Miss

    OSINT Attacks: The Exposure Gap That Phishing Drills Miss

    Every October, with Cybersecurity Awareness Month, MFA, strong passwords, and phishing simulation drills take center stage. Each time this training repeats in real-world environments, one frustrating question persists: if attackers already know an employee’s name, job title, home address, and even their manager’s pet’s name, what exactly can training that merely lowers phishing click-through rates actually stop? Public-source attacks drive directly into this gap.

    Attackers already know you

    OSINT (Open Source Intelligence) attacks are an extended form of social engineering that builds an attack surface using only publicly available information, without any hacking. A name, company, job title, phone number, and address can easily be collected simply by querying a few people-search sites. When current employer information from LinkedIn is layered on, cases are repeatedly reported of new hires receiving CEO gift card scam emails. One operator shared that upon reactivating their own LinkedIn account, roughly half of their users began receiving emails impersonating them. Cases have also been shared of operators approaching employees by directly naming them during phone calls, as well as operators who deleted LinkedIn entirely or reduced it to skeleton profiles unconnected to their current employer.

    The blind spot in awareness month curriculum

    The importance of MFA, EDR, and phishing awareness training is undeniable. However, the recognition that the human layer has already been effectively compromised at the pre-attack stage is missing. If an attacker has gathered a manager’s pet’s name through data brokers and then calls the help desk, technical controls alone cannot block that point of entry. The “training to suspect” emphasized in awareness month education is effective only against callers without context, but is powerless against callers equipped with context. As AI-based impersonation becomes widespread, this asymmetry continues to widen.

    A four-step practical framework

    To integrate the OSINT attack surface as a standard assessment item in the consulting process, the following sequence is effective.

    1. Make the risk visible through live demonstration — In a client meeting, query people-search sites using the names of executives and security team members to show actual exposed data, and most immediately recognize the risk. “Is it acceptable for our information to be exposed to that extent?” is a typical reaction, and most organizations have never self-assessed their employee exposure levels.

    2. Distribute a quarterly self-audit checklist — Have employees self-check their LinkedIn profile visibility, internal directory listings, contact information in email signatures, and personal cell phone exposure. The principle that information identifying a current employer should not be registered on public sites unless one is actively job-seeking should be explicitly stated in internal guidelines.

    3. Opt out during new hire onboarding — Before a new hire posts their joining on LinkedIn, guide them to complete opt-out procedures at major data brokers. Review of fake email and phone number issuance services should also be addressed at this stage.

    4. Annual risk grading — Explicitly add an “OSINT Attack Surface” section to the consulting report template, and update employee exposure grades as A/B/C. The key is formal incorporation as part of client advisory items, not simple risk flagging.

    Tools available for assessment

    Public digital footprint mapping can begin with manual queries alone. If automation is needed, public tools such as Maltego CE, SpiderFoot, theHarvester, and Mozilla Monitor can be reviewed for reference. (These are practical recommendation tools not discussed in the original thread and are not official specifications.) The conceptual flow is as follows.

    ※ Note: The following commands are conceptual simulation examples (Illustrative Example, not official spec).

    # Collect emails and subdomains for your domain using theHarvester
    theHarvester -d example.com -b linkedin,google,bing -l 200
    
    # Automated scan of your domain with SpiderFoot
    spiderfoot -s example.com -t all
    

    Anti-patterns to avoid

    It is typical to assess awareness level solely by phishing simulation click rates while omitting OSINT exposure assessment. Operations that treat data broker opt-out as a one-time project without re-monitoring for new leak pathways are cited as common failure patterns. As AI impersonation becomes widespread, organizations that do not specify suspicious-activity reporting hotlines and callback or one-time code authentication procedures in their manuals become targets. The illusion that technical controls alone can close every surface is especially dangerous in the face of the OSINT attack surface.

    Shift the focus of Awareness Month from “suspicion” to “exposure control”

    Even when phishing simulation pass rates are high, if the OSINT attack surface remains open, the attack entry point exists outside the training category. Raising employee digital exposure to a regular checklist item from the consulting stage is the substantive defense line that awareness month overlooks. The original discussion can be reviewed in the r/sysadmin thread.

    What to do right now

    • Query people-search sites with your own name and note the exposed items.
    • On LinkedIn, minimize the public visibility of current employer name, department, title, and email.
    • Check whether your internal email signature includes unnecessary contact information such as cell phone or direct numbers.
    • Run a single email collection against your domain using theHarvester to gauge data broker exposure range.
    • Add a “Complete data broker opt-out before announcing employment” item to the new hire onboarding guide.

    Reference source

    This article was prepared after reviewing the following source: r/sysadmin — It’s Cybersecurity Awareness Month but are we overlooking something pretty obvious?

  • Overcoming MFA Limits: Enterprise 90-Day Zero Trust Roadmap

    Overcoming MFA Limits: Enterprise 90-Day Zero Trust Roadmap

    Key Takeaways

    • Why MFA gets bypassed structurally: MFA protects only the moment an authentication token is created (session cookies, refresh tokens, and OAuth tokens each require separate protection thereafter), and SMS/email-based MFA—vulnerable to phishing, reverse proxies (AitM attacks like Evilginx2), MFA fatigue, and SIM swapping—is still widely deployed. In addition, some solutions labeled ‘MFA’ are in practice only passwordless logins, which worsens both user fatigue and the phishing surface (the original post cites Microsoft Authenticator as an example).
    • Practical decision criteria: Rather than picking a single priority, organizations should separately measure the maturity of three axes as distinct KPIs—(1) phishing-resistant authentication adoption (FIDO2/passkeys, device-bound, unmanaged fallback options (SMS/voice) disabled), (2) post-authentication session protection (bound sessions, shortened token lifetimes, token-theft response), and (3) post-auth detection and response (UEBA, risk scoring based on behavioral anomalies, ITDR)—and reinforce the weakest axis first. The community consensus is that ‘a good window and a good door’ are both required; strengthening only one side makes the other the largest attack surface.
    • Anti-patterns to avoid: ① Treating SMS/email-only MFA as ‘good enough’ and not advancing to the next stage. ② Cutting post-authentication visibility and detection investment to near zero once MFA rollout is declared ‘complete.’ ③ Defaulting to simple push approval on every login without number matching, which invites MFA fatigue. ④ Logging abnormal sign-in notifications without review or action. ⑤ Splitting identity/authentication and SOC detection into separate teams and tools so that event context is fragmented. Because social engineering can bypass any technical control, the ‘people’ axis—training and procedures—must receive budget on par with the technology stack.

    MFA is only a first gate that guards the single moment an authentication token is created, so treating ‘stronger authentication’ and ‘post-authentication visibility and detection’ as a binary choice rather than as two axes of the same defense-in-depth posture is a mistake. Identifying the weakest axis in the organization and reinforcing it first is the core lever for materially reducing the attack surface.

    Table of Contents

    Diagram of MFA limits and post-auth detection operations

    Even after MFA is rolled out, incidents involving session hijacking, credential leakage, and post-authentication anomalous activity continue to be reported on a regular basis. From an engineering standpoint, this is no longer a problem confined to ‘organizations without MFA.’ Whether the stack is Microsoft Entra, Okta, or Google Workspace, the MFA checkbox is enabled and yet incident reports keep piling up, while security operations teams face pressure every quarter to write the same kind of post-mortem.

    In the original thread (r/cybersecurity – Are we putting too much faith in MFA?), operators raise a common dilemma: ‘Should we make authentication itself stronger with FIDO2/passkeys, or invest in precise detection and response of post-authentication behavior?’ The question of which one to do first rarely yields a useful answer in practice. These two are not competing choices but two axes of the same defense.

    Where MFA Stops and Where It Starts to Leak

    MFA protects only the single moment an authentication token is created. It can block a user up to the point where they pass the password and OTP and a SAML/OIDC token is issued, but the session cookie, refresh token, and OAuth access token that come after require separate controls. The attack vectors that exploit this blind spot are already standardized.

    A representative example is the AitM (Adversary-in-the-Middle) reverse proxy attacks represented by Evilginx2. The attacker routes the login page through a reverse proxy that looks like the legitimate domain to the user, intercepting the entered credentials and session cookie. At the moment MFA succeeds and the token is issued, that token is already in the attacker’s hands. SMS OTP, TOTP, and simple push authentication do not provide the same level of phishing resistance against this vector. SMS/email-based MFA is therefore classified as the area where MFA’s limits are most pronounced.

    MFA fatigue attacks reach the same conclusion. An attacker bombards a single user with dozens of push notifications, making it impossible to distinguish legitimate from malicious alerts, and ultimately secures a single accidental approval. Even when the authentication channel is multi-factor, it is bypassed by social engineering. With Microsoft Authenticator enforcing number matching, simple push fatigue is largely neutralized; however, legacy push mechanisms and persistent prompt spamming remain threats.

    Community Consensus: ‘A Good Window and a Good Door’ Are Both Required

    The consensus that recurs in r/cybersecurity and r/netsec is clear: ‘You need both a good window and a good door.’ Stronger authentication and post-auth detection are not a priority contest; they are two axes whose maturity must be measured simultaneously. Strengthening only one makes the other the largest attack surface.

    Even in an organization that has rolled out passkeys at 100%, if session tokens remain valid for eight hours and no UEBA is in place to detect AitM attacks that intercept them, users are exposed to a new pattern: ‘not phished, but their session is stolen.’ Conversely, even with hundreds of detection rules in SIEM/SOAR, if user authentication still relies on SMS OTP, attackers keep breaking through with the same phishing template. The real decision criterion is not ‘what is more important’ but ‘which axis is weaker.’ Measuring the maturity of all three axes as separate KPIs and reinforcing the lowest-scoring axis first is the only path that materially reduces the attack surface.

    Diagnostic Framework: 3-Axis Self-Assessment

    The maturity of the phishing-resistant authentication axis can be classified into stages 0 through 3. Stage 0 uses only SMS/email OTP. Stage 1 introduces TOTP or push authentication. Stage 2 applies FIDO2/passkeys only to high-risk accounts and administrators. Stage 3 applies FIDO2/passkeys device-bound to all users, with unmanaged fallback options (SMS/voice) disabled.

    The session and privilege control axis is measured by access token lifetime, refresh token rotation, application of CAE (Continuous Access Evaluation), and adoption of PIM/JIT privilege models. The post-authentication detection axis is evaluated by ITDR tool presence, UEBA-based risk scoring, SIEM/SOAR integration, and the review/action SLA for post-event alerts. If any of the three axes is below stage 1, reinforcing that axis first yields the highest incident-prevention ROI. Budget should be spread to lift all three axes in balance only when most are already at stages 2–3.

    Axis 1: Strengthening Phishing-Resistant Authentication — FIDO2/Passkeys

    The first practical task is to visualize enrollment rates. In Microsoft Entra ID, the following PowerShell command retrieves passkey registration status immediately.

    Get-MgReportAuthenticationMethodUserRegistrationDetail `
      -Filter "methodsRegistered/any(m:m eq 'passKey')" `
      | Select-Object UserPrincipalName, IsMfaRegistered, IsPasswordlessCapable, MethodsRegistered

    If enrollment rates are low, the Authentication Strengths policy in Conditional Access should be incrementally raised to require ‘Phishing-resistant MFA.’ Okta’s Phishing-Resistant Authentication policy can be forced to allow only device-bound WebAuthn, and Google Workspace achieves the same effect via the Advanced Protection Program and Security Key Enforcement. Per-login simple push (one-time approval without number matching) should be phased out.

    The standard timeline to retire SMS/email MFA is 90 days. Days 1–30 are for inventory and exception-account classification. Days 31–60 are for enforcing FIDO2 on administrators and high-risk groups. Days 61–90 are for organization-wide rollout to all users, with SMS demoted to a ‘break-glass account.’ Reverting to simple push approval as the default to spare user friction is the most common regression in this process.

    Axis 2: Post-Authentication Visibility — ITDR + SIEM/SOAR

    To route post-authentication events into a SIEM, both IdP logs and identity-related events are required. Microsoft Defender for Identity, CrowdStrike Falcon Identity Protection, Push Security, Obsidian Security, and BeyondTrust fall under the ITDR category, and they route events into SIEMs such as Sentinel, Splunk, or Elastic, and into SOARs such as Tines or Cortex XSOAR.

    The first five detection rules to implement are: ① Token reuse from anomalous times, geographies, or ASNs. ② Impossible Travel (long-distance location jumps within a short window). ③ MFA fatigue/spray patterns (many push requests to a single user in a short window, or simultaneous pushes to many users). ④ Automatic creation of mailbox rules (an attacker persistence indicator). ⑤ OAuth privilege escalation and consent grant events (especially broad scopes such as Mail.Read and Files.ReadWrite).

    A Sentinel KQL example based on Microsoft Entra ID sign-in logs is as follows.

    SigninLogs
    | where ResultType == 0  // successful sign-in
    | where AppDisplayName in ("Office 365 Exchange Online", "Microsoft Graph")
    | summarize SignInCount = count(),
                DistinctCountries = dcount(LocationDetails.countryOrRegion),
                DistinctCities   = dcount(LocationDetails.city)
                by UserPrincipalName, bin(TimeGenerated, 1h)
    | where DistinctCountries > 1 or DistinctCities > 2
    | order by TimeGenerated desc

    The query above detects successful sign-ins from multiple countries or cities within a one-hour window. A separate Impossible Travel rule is maintained for the same user, calculating risk from the time delta and geographic distance between two events. Alerts must be bound to a review-and-action SLA. High/critical sign-ins should be confirmed and blocked by the SOC within 30 minutes via an on-call rotation. The key is to avoid building alert channels that only log without anyone watching them.

    Axis 3: Session and Privilege Control — CAE + PIM/JIT

    The goal of the third axis is to minimize the usable lifetime of a stolen token. Enabling Continuous Access Evaluation (CAE) in Microsoft Entra ID immediately invalidates a token when user state changes occur (account disabled, password changed, device compliance lost). Access token lifetime should be shortened to 15–60 minutes, and refresh token rotation should be enforced.

    Conditional Access policy example (Microsoft Graph API call format):

    {
      "displayName": "Require Phishing-Resistant + Compliant Device",
      "state": "enabledForReportingButNotEnforced",
      "conditions": {
        "users": { "includeGroups": ["<all-staff-group-id>"] },
        "applications": { "includeApplications": ["All"] },
        "signInRiskLevels": ["medium", "high"],
        "clientAppTypes": ["browser", "mobileAppsAndDesktopClients"]
      },
      "grantControls": {
        "operator": "OR",
        "builtInControls": [
          "compliantDevice",
          "domainJoinedDevice"
        ],
        "authenticationStrength@odata.bind": "https://graph.microsoft.com/v1.0/identity/conditionalAccess/authenticationStrength/policies('00000000-0000-0000-0000-000000000002')"
      },
      "sessionControls": {
        "signInFrequency": { "value": 1, "type": "hours" },
        "persistentBrowser": { "mode": "never" },
        "continuousAccessEvaluation": { "mode": "strictEnforcement" }
      }
    }

    Administrative privileges should be transitioned from a standing-permission model to a JIT (Just-In-Time) elevation model under PIM (Privileged Identity Management). Time limits (for example, 1–4 hours), approval workflows, and activity logs should be enforced at role activation, narrowing the window for privilege abuse and lateral movement.

    Five Anti-Patterns to Avoid

    First, treating SMS/email-only MFA as ‘good enough’ and not advancing to the next stage. It is often justified on cost and accessibility grounds, but the fundamental lack of phishing resistance that defines MFA’s limits does not change. Second, letting post-authentication visibility and detection investment shrink to near zero once MFA rollout is declared ‘complete.’ Cutting SOC headcount and tooling budgets because authentication is ‘solved’ is the pattern most frequently observed just before an incident.

    Third, defaulting to per-login simple push approval in the name of user convenience. Push notifications that operate without number matching are directly exposed to MFA fatigue attacks. Fourth, logging abnormal sign-in notifications without review or action. Alerts are meaningful only when operated on the assumption that ‘a human sees them and decides.’ Fifth, splitting identity/authentication and SOC detection into separate teams and tools so that event context is fragmented. Having the identity team and the SOC team each analyze the same incident from different vantage points multiplies MTTR by 2–3×.

    Because social engineering can bypass any technical control, the ‘people’ axis—training and procedures—must receive budget on par with the technology stack. Phishing simulations should be run not as a simple awareness program but as a feedback loop into system improvement (see also 7-Step Practical Procedure for Repeat Phishing Simulation Failures).

    90-Day Execution Roadmap

    Days 0–30 (Diagnose): Compute the 3-axis self-assessment score, map the user distribution by enrolled authentication method, and inventory token lifetime and session policies. The output is consolidated into a single dashboard.

    Days 31–60 (Pilot): Enforce FIDO2/passkeys on high-risk groups (administrators, finance, security), deploy the first ITDR rule set, and operate the token-lifetime shortening policy in report-only mode. Measure false-positive rates on detection alerts and tune the rules accordingly.

    Days 61–90 (Enforce): Switch enterprise-wide policies to enforce mode, enable CAE, apply PIM JIT organization-wide, and bring the alert on-call rotation online. Track KPIs including passkey enrollment rate, percentage of high-risk sign-ins blocked within 30 minutes, average JIT activation time, and alert-review SLA compliance rate.

    What to Do Right Now

    • In the IdP console, immediately query the share of users still on SMS/email-only MFA and plot a distribution chart.
    • Select 20 high-risk-group users (Global Admin, Exchange Admin, security team) and prioritize FIDO2 passkey enrollment for them, reporting progress weekly until registration is complete.
    • Deploy at least one ‘successful sign-ins across multiple countries/cities within a short window’ rule in the SIEM and compute the false-positive rate against the last 7 days of historical logs.
    • Turn on a Conditional Access session policy that shortens sign-in frequency (re-authentication interval) in report-only mode (token lifetimes are governed separately via Token Lifetime Policies) and measure the number of affected users.
    • Switch administrative role activation requests to PIM/JIT and enforce a 4-hour maximum privilege duration.

    Frequently Asked Questions

    How is legacy system compatibility handled when adopting FIDO2/passkeys?

    Legacy apps that do not support WebAuthn are realistically classified as a separate ‘exception group’ and excluded from the authentication strength requirement in Conditional Access. However, that group should have ITDR detection strength doubled and sign-in frequency shortened to 30–60 minutes as compensating controls. Exceptions are not a permanent state; they are reviewed quarterly and reduced.

    If detection alerts overwhelm the SOC, how should priorities be assigned?

    First, automatically block (or forcibly terminate sessions for) only the combination of ‘successful authentication + anomalous location/time’ as a tier-1 automated action, and route the remaining alerts to a daily batch review. Alert severity itself must be redesigned around user impact to reduce alert fatigue. The direction is to tune toward fewer, more meaningful alerts rather than more alerts.

    How is the cost justification for the 3-axis reinforcement explained to executives?

    Calculate the average cost of a single breach (investigation, recovery, regulatory response, brand damage) for the organization’s industry, then present scenarios showing how much incident frequency and MTTR each decrease when all three axes move from stage 1 to stage 2. Technology budgets are most persuasive when justified as a ratio against the cost of avoided incidents.

    Source

    This article was prepared with reference to the following original thread: r/cybersecurity — Are we putting too much faith in MFA?