<?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/">
  <channel>
    <title>DEV Community: IRM Consulting &amp; Advisory</title>
    <description>The latest articles on DEV Community by IRM Consulting &amp; Advisory (@irmcon).</description>
    <link>https://dev.to/irmcon</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4118063%2F8cac1437-7a7e-4ee6-8bdc-a87d8f10857b.webp</url>
      <title>DEV Community: IRM Consulting &amp; Advisory</title>
      <link>https://dev.to/irmcon</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/irmcon"/>
    <language>en</language>
    <item>
      <title>The access you forgot to revoke: an offboarding runbook for small engineering teams</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Sat, 14 Nov 2026 00:51:21 +0000</pubDate>
      <link>https://dev.to/irmcon/the-access-you-forgot-to-revoke-an-offboarding-runbook-for-small-engineering-teams-je1</link>
      <guid>https://dev.to/irmcon/the-access-you-forgot-to-revoke-an-offboarding-runbook-for-small-engineering-teams-je1</guid>
      <description>&lt;p&gt;Somebody leaves. Their manager disables the account in the identity provider, the laptop comes back, and everyone moves on. Six weeks later a CI job fails with a token nobody recognises, or a customer security questionnaire asks how long it takes you to revoke access and nobody can answer with a number.&lt;/p&gt;

&lt;p&gt;Offboarding is one of the few security controls where a small team can genuinely match a large one, because the whole thing is a list and a habit. The reason it goes wrong is not sophistication. It is that access was granted in eleven places over two years and revoked in one.&lt;/p&gt;

&lt;p&gt;Here is the version I would actually run on a team of ten to fifty engineers.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Build the list while nobody is leaving
&lt;/h2&gt;

&lt;p&gt;The worst time to discover where access lives is the afternoon somebody resigns. Write the list first, when it is a boring exercise instead of an urgent one.&lt;/p&gt;

&lt;p&gt;Walk your own stack and write down every system that can grant a human access to code, data, infrastructure or money:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Identity provider or directory: Entra ID, Okta, Google Workspace, JumpCloud.&lt;/li&gt;
&lt;li&gt;Cloud: AWS, Azure, GCP, including any account with its own local users rather than federated ones.&lt;/li&gt;
&lt;li&gt;Source control and package registries: GitHub, GitLab, npm, PyPI, container registries.&lt;/li&gt;
&lt;li&gt;CI and deployment: the pipeline itself, plus anywhere a secret is stored for it.&lt;/li&gt;
&lt;li&gt;Data: production databases, warehouses, BI tools, object storage with its own signed URLs.&lt;/li&gt;
&lt;li&gt;Vendors with their own logins: monitoring, error tracking, feature flags, payment processors, support desks.&lt;/li&gt;
&lt;li&gt;Collaboration: chat, docs, project tracking, design tools, shared drives.&lt;/li&gt;
&lt;li&gt;Access to the perimeter: VPN, bastion hosts, jump boxes, remote support tools.&lt;/li&gt;
&lt;li&gt;The password manager, which is the system that quietly grants access to all of the above.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two columns are enough: who administers it, and whether it federates through the identity provider or holds its own local accounts. That second column is the one that matters, and it is the one most teams have never filled in.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. The identity provider is the first move, not the whole move
&lt;/h2&gt;

&lt;p&gt;Suspending the directory account is the highest value action available in the first minute, so do it first. Then treat it as incomplete, because federation is almost never total. The systems that were signed up for before single sign on existed, the ones on a plan that does not include SAML, and the one somebody integrated in a hurry are all still holding local credentials.&lt;/p&gt;

&lt;p&gt;There is also a difference between a credential and a session. Disabling an account stops new sign ins. It does not always end the sessions already issued. Where the system offers it, revoke active sessions and refresh tokens explicitly rather than assuming the account change propagated.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Tokens outlive people
&lt;/h2&gt;

&lt;p&gt;This is where the real residual access sits, and it is invisible from the identity provider.&lt;/p&gt;

&lt;p&gt;Long lived credentials that a person created, but which are not tied to that person's login lifecycle:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Personal access tokens in source control, often used in scripts that other people now depend on.&lt;/li&gt;
&lt;li&gt;SSH keys registered against the account, and any key pasted into an authorized_keys file on a host.&lt;/li&gt;
&lt;li&gt;Cloud access key pairs on a local IAM user.&lt;/li&gt;
&lt;li&gt;API keys issued from vendor dashboards, which usually keep working after the creator is deactivated.&lt;/li&gt;
&lt;li&gt;OAuth application grants and installed integrations approved with their account.&lt;/li&gt;
&lt;li&gt;Webhook secrets and signing keys they generated.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Enumerate these per departure, not once a year. And when you find a token that something in production depends on, do not simply delete it and hope. Reissue it against a service identity that belongs to the system rather than to a person, then delete the old one. Doing that at offboarding time is how the problem stops recurring.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Shared credentials are the reason offboarding fails
&lt;/h2&gt;

&lt;p&gt;If two people know a password, offboarding one of them does not revoke it. The account still works, the login looks legitimate, and no audit trail will tell you who used it.&lt;/p&gt;

&lt;p&gt;Shared logins collect in predictable places: the domain registrar, the DNS provider, the payment processor, the app store accounts, the ISP or hosting portal, the social media accounts, and anything with a per seat price that somebody decided to avoid. When a departure exposes one, rotate it and record who holds it now.&lt;/p&gt;

&lt;p&gt;Rotate every shared secret the leaver could read. That includes vault entries their group had access to, even where you have no evidence they opened them. Access is the thing being revoked, not usage.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Handle the second factor deliberately
&lt;/h2&gt;

&lt;p&gt;MFA is part of the credential set. Remove the registered authenticator, hardware key and recovery codes for the person who left, and check whether their phone number is still the recovery route on any account. A password reset flow that texts a former employee is a live path back in, and it survives every other step in this list.&lt;/p&gt;

&lt;p&gt;While you are there, look at whether any break glass or emergency account has their contact details attached.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Devices, and the data already on them
&lt;/h2&gt;

&lt;p&gt;Returning a laptop is not the same as clearing it. Confirm the device is unenrolled or wiped through your management tooling, not by inspection. Then think about copies: personal cloud storage syncing a work folder, a local database dump in a downloads directory, an exported spreadsheet, a repository cloned to a personal machine.&lt;/p&gt;

&lt;p&gt;You cannot revoke a copy that already left. You can notice that it happened and decide what it means, which is a different and more honest position than assuming it did not.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Write it down the same way every time
&lt;/h2&gt;

&lt;p&gt;Use one checklist per departure, with a timestamp against each item and the name of the person who did it. Store it somewhere that is not the leaver's own drive.&lt;/p&gt;

&lt;p&gt;This is the part that feels like bureaucracy and is actually the part that pays. It gives you a real answer to how long revocation takes, it makes the gap visible when one system is always skipped, and it means that when a customer or an auditor asks for evidence you are retrieving a record rather than reconstructing a memory. A control you perform but cannot show is treated, by anyone assessing you from outside, as a control you do not have.&lt;/p&gt;

&lt;p&gt;Keep the same checklist for contractors, and for anyone who changes role internally. Internal moves are worse than departures, because nothing prompts anybody to take the old access away.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Test it on yourself
&lt;/h2&gt;

&lt;p&gt;Pick a quiet week and offboard a volunteer who is not leaving. Run the checklist against a real account and then try, honestly, to get back in: old token, saved session, shared login, recovery flow, VPN profile. You will find two or three things the list missed. Add them and run it again next quarter.&lt;/p&gt;

&lt;p&gt;That drill takes an afternoon and it is the only way to know whether the runbook describes your environment or the environment you meant to build. Baseline control sets, if you want a reference for what to cover, treat access provisioning and revocation as one control with two halves: &lt;a href="https://irmcon.com/products/cybersecurity-baseline-assessment/" rel="noopener noreferrer"&gt;https://irmcon.com/products/cybersecurity-baseline-assessment/&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The bit where I say who I am
&lt;/h2&gt;

&lt;p&gt;I work at IRM Consulting &amp;amp; Advisory, where I do virtual and fractional CISO work with small businesses, startups and SaaS companies in Canada and the United States, so offboarding gaps are something I get paid to go looking for. If you want the version of this that comes with someone accountable for it, that is &lt;a href="https://irmcon.com/virtual-ciso-services-vciso/" rel="noopener noreferrer"&gt;IRM's virtual CISO practice&lt;/a&gt;. Flagging the affiliation so you can weigh the advice accordingly.&lt;/p&gt;

&lt;p&gt;One question, because I am curious how other teams handle it: when a departure exposes a token that production depends on, do you reissue it to a service identity there and then, or do you note it and move on? The second answer is more common than anyone admits.&lt;/p&gt;

</description>
      <category>security</category>
      <category>devops</category>
      <category>startup</category>
    </item>
    <item>
      <title>AI governance that fits in a pull request</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Wed, 04 Nov 2026 14:38:13 +0000</pubDate>
      <link>https://dev.to/irmcon/ai-governance-that-fits-in-a-pull-request-1k1b</link>
      <guid>https://dev.to/irmcon/ai-governance-that-fits-in-a-pull-request-1k1b</guid>
      <description>&lt;p&gt;Most AI governance lands on engineering teams as a document. Someone writes an acceptable use policy, it is circulated, and nothing about how anyone works actually changes. Six months later a customer asks which of their data has been sent to a model provider and the policy turns out not to answer that.&lt;/p&gt;

&lt;p&gt;Governance only holds when it is a property of the workflow rather than a file in the wiki. Below is what that looks like in practice for a team that ships software, with the controls expressed as things that happen in a repository rather than things people are supposed to remember.&lt;/p&gt;

&lt;p&gt;None of this requires a certification programme. It happens to line up with the standard frameworks, which is convenient later, but the reason to do it is that it answers questions you will be asked.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Classify the data before it reaches a provider, in code
&lt;/h2&gt;

&lt;p&gt;The single most useful control is also the least glamorous: know what you are sending.&lt;/p&gt;

&lt;p&gt;If your application sends user content to a model API, that call site is a trust boundary and should be treated like one. In practice:&lt;/p&gt;

&lt;p&gt;Put model calls behind one internal client rather than calling the provider SDK from twelve places. That gives you exactly one place to add redaction, logging and limits, and one place to change providers.&lt;/p&gt;

&lt;p&gt;Make the caller declare the data class. A required argument, not a convention: internal, customer content, or restricted. Reject restricted at the boundary unless there is an explicit allowance.&lt;/p&gt;

&lt;p&gt;Strip what you do not need before the call. Identifiers, emails, and free-text fields that nobody asked the model to reason about are the usual offenders.&lt;/p&gt;

&lt;p&gt;The test for this control is simple. Someone should be able to answer "what categories of data has this product sent to a model provider?" by reading one module, not by interviewing the team.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Log the prompt, the response, and the version
&lt;/h2&gt;

&lt;p&gt;Treat inference like any other external call you would be embarrassed not to have logged.&lt;/p&gt;

&lt;p&gt;At minimum, record the model and version, the timestamp, the caller, a hash of the input, and whether the output was used or discarded. Whether you store the full prompt text depends on what is in it, which is exactly why step one comes first.&lt;/p&gt;

&lt;p&gt;The reason is not compliance theatre. When a model changes behaviour after a provider updates a version, this log is the only way to tell whether your output changed with it. Without it you are debugging a system whose behaviour is not reproducible and whose history you did not keep.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Pin versions and treat a model change as a deploy
&lt;/h2&gt;

&lt;p&gt;A model identifier that points at "latest" is an unreviewed dependency update in production, applied by somebody else, on their schedule.&lt;/p&gt;

&lt;p&gt;Pin to an explicit version. Put the upgrade through the same path as any other dependency bump: a change, a review, a test run, a deploy you can roll back. Providers deprecate versions, so track the deprecation dates somewhere that will interrupt you before the cutoff rather than after.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Make evaluations part of the test suite
&lt;/h2&gt;

&lt;p&gt;If the output of a model affects what a user sees, you need a regression test for it, and "we tried it and it looked good" is not one.&lt;/p&gt;

&lt;p&gt;Keep a small set of fixed inputs with expected properties, and assert on properties rather than exact strings: refusals happen where they should, required fields are present, outputs stay inside length and format bounds, and known bad inputs do not produce the bad output they used to. Run it in CI on every change to the prompt, the model version, or the surrounding code.&lt;/p&gt;

&lt;p&gt;This is the control that catches the prompt edit that quietly broke the thing nobody was looking at. It is also, not incidentally, the evidence an assessor wants when they ask how you know the system performs as intended.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Put the AI question in the pull request template
&lt;/h2&gt;

&lt;p&gt;Three checkboxes, applied only when a change touches a model call:&lt;/p&gt;

&lt;p&gt;Does this change what data is sent to a provider? Does this change the model, the version, or the provider? Does this output reach a user without a human in between?&lt;/p&gt;

&lt;p&gt;Any yes routes to a short review. Nothing else does. The reason this works where a policy document does not is that it appears at the moment the decision is being made, by the person making it, and takes fifteen seconds when the answer is no.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Decide where a human belongs, and write it down once
&lt;/h2&gt;

&lt;p&gt;"Human in the loop" is used as though it means one thing. It needs to be specific per feature, and the honest version is a sentence in the code review, not a principle in a policy.&lt;/p&gt;

&lt;p&gt;The useful distinction is what the output does. Output that informs a person who then decides needs little. Output that is shown to a customer as though authoritative needs review of the failure mode, not of every instance. Output that triggers an action, sends a message, moves money, changes access, needs a person or a hard constraint in front of it, every time.&lt;/p&gt;

&lt;p&gt;Write which of those three applies next to the feature. When it changes, the pull request template in step five catches it.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Give agents the same scrutiny as a new employee
&lt;/h2&gt;

&lt;p&gt;An agent with a token is a principal in your system, and the questions are the ones you would ask about any other account.&lt;/p&gt;

&lt;p&gt;What can it reach, and is that scope the minimum? Whose credential is it using, and is it a service identity rather than a person's token? What is the revocation path, and has anyone tested it? Is its activity attributable in your logs, or does it appear as the human whose token it borrowed?&lt;/p&gt;

&lt;p&gt;That last one is the common failure, and it is the one that makes an incident unreconstructable. An agent acting under a person's credential means your audit trail is wrong about who did what.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Keep the register short enough to stay true
&lt;/h2&gt;

&lt;p&gt;One row per AI-enabled feature: what it does, which model and version, what data it sees, where the human sits, and who owns it. Five columns, in version control, next to the code.&lt;/p&gt;

&lt;p&gt;A register that is complete and shallow beats a thorough one covering a third of your systems, because the gap in the thorough one is invisible. If you want a reference for the fuller control set this maps onto, &lt;a href="https://irmcon.com/products/iso42001/" rel="noopener noreferrer"&gt;IRM's free ISO 42001 gap assessment&lt;/a&gt; walks Clauses 4 to 10 and the 38 Annex A controls, which is a reasonable map of what a mature version of this looks like.&lt;/p&gt;

&lt;h2&gt;
  
  
  About IRM's AI Governance services
&lt;/h2&gt;

&lt;p&gt;Disclosure first, so you can weigh the advice accordingly: this post comes from IRM Consulting &amp;amp; Advisory, and the links in it point to our own pages.&lt;/p&gt;

&lt;p&gt;The gap this post is about is the one we see most: governance written as policy for a company that builds software, with nothing connecting it to the pull request where the decisions actually get made. The fix is rarely more documentation. It is usually a handful of controls relocated into the workflow, which is cheaper and holds better.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://irmcon.com/iso42001-consulting/" rel="noopener noreferrer"&gt;IRM Consulting &amp;amp; Advisory&lt;/a&gt; provides AI governance and ISO 42001 consulting to SaaS and AI-first companies in Canada and the United States, covering AIMS scoping, AI risk assessments and the Annex A controls.&lt;/p&gt;

&lt;p&gt;One question for anyone further along than this: have you found a way to version prompts that your team actually sticks to? Everyone agrees they should be versioned and almost nobody treats them like code.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devops</category>
      <category>programming</category>
    </item>
    <item>
      <title>A discovery runbook for shadow AI, using logs you already have</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Wed, 04 Nov 2026 14:27:08 +0000</pubDate>
      <link>https://dev.to/irmcon/a-discovery-runbook-for-shadow-ai-using-logs-you-already-have-416g</link>
      <guid>https://dev.to/irmcon/a-discovery-runbook-for-shadow-ai-using-logs-you-already-have-416g</guid>
      <description>&lt;p&gt;Most advice about shadow AI starts by telling you to survey your staff. Try it and you get a partial list, because people answer honestly about the tools they think count and forget the browser extension that summarises their email.&lt;/p&gt;

&lt;p&gt;The better starting point is that you are already collecting the evidence. Every company of fifty people has four or five telemetry sources that know exactly which AI services its laptops and servers talk to. Nobody has pointed them at this question yet.&lt;/p&gt;

&lt;p&gt;Here is a discovery runbook that uses what you already have, in rough order of how much it returns per hour spent.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Decide what you are actually looking for
&lt;/h2&gt;

&lt;p&gt;Write this down before you query anything, because otherwise the list balloons and you abandon it.&lt;/p&gt;

&lt;p&gt;You are looking for three distinct things, and they need different responses:&lt;/p&gt;

&lt;p&gt;Services that receive your data. A person pastes a customer support thread into a chat assistant, or a tool sends document contents to a provider to summarise them. This is the category that matters for confidentiality and for your customer commitments.&lt;/p&gt;

&lt;p&gt;Services that write code or config that ships. An assistant in the IDE, a bot that opens pull requests, a pipeline step that generates something. The risk here is provenance and review, not disclosure.&lt;/p&gt;

&lt;p&gt;Agents with credentials. Anything that holds a token and acts on its own: a scheduled job, an integration with repository write access, an assistant connected to your ticketing system. Small in number, largest in blast radius, and almost never on anybody's list.&lt;/p&gt;

&lt;p&gt;A tool can be in more than one category. The point is that "we use AI" is not a finding, and "this tool holds a repo-scoped token and sends ticket contents to a third party" is.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Start with DNS and egress logs
&lt;/h2&gt;

&lt;p&gt;This is the highest yield hour in the whole exercise.&lt;/p&gt;

&lt;p&gt;Your resolver, firewall, or cloud egress logs already record which hostnames your network talks to. Query them for the API hostnames of the major model providers and the common wrapper services, over a ninety day window, grouped by source host and by volume.&lt;/p&gt;

&lt;p&gt;Three patterns worth reading carefully:&lt;/p&gt;

&lt;p&gt;Steady low-volume traffic from one workstation is usually one person with a browser extension or desktop app.&lt;/p&gt;

&lt;p&gt;Traffic from a server or container, not a laptop, means something in your own stack is calling a model. That is a product decision somebody made, and it belongs in your architecture documentation whether or not anyone wrote it down.&lt;/p&gt;

&lt;p&gt;A spike that starts on a specific date and never stops is an integration that got switched on. Find the date, then find the change that landed that week.&lt;/p&gt;

&lt;p&gt;If you have no egress logging at all, that is a finding in its own right and probably a bigger one than the AI question.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Pull the OAuth and connected-app lists
&lt;/h2&gt;

&lt;p&gt;Every place a person can click "allow" is a place an AI tool can attach itself to your data without anybody buying anything.&lt;/p&gt;

&lt;p&gt;Check the connected applications list in your identity provider, the installed apps and OAuth grants in your source control organisation, the add-ons and marketplace apps in your document suite, and the integrations in your chat tool and ticketing system.&lt;/p&gt;

&lt;p&gt;For each one, record the scopes rather than the name. An assistant with read access to a calendar is not interesting. The same vendor with read and write access to every repository is a different conversation. Scopes are the only part of this that tells you anything about consequence.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Look at the endpoints, carefully and with the lightest touch that works
&lt;/h2&gt;

&lt;p&gt;Browser extensions and desktop applications are where most individual usage lives.&lt;/p&gt;

&lt;p&gt;If you have device management, an installed-application inventory and a browser extension inventory will answer this in minutes. If you do not, you can ask, and you will get a partial answer.&lt;/p&gt;

&lt;p&gt;Be deliberate about proportionality here. There is a real difference between inventorying installed software and reading what people type, and the second one damages the trust you need for the rest of this programme to work. You are building a list of tools, not monitoring individuals. Say that out loud when you ask, and mean it, because the moment this feels like surveillance people route around you and your inventory becomes fiction.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Read the expense data last, not first
&lt;/h2&gt;

&lt;p&gt;Card statements and the subscriptions list will surface paid tools, which is useful and incomplete. Almost everything interesting in shadow AI is on a free tier, which is precisely why it never passed through procurement.&lt;/p&gt;

&lt;p&gt;Do pull it, because reconciling it against the DNS findings is informative in both directions. A tool you are paying for that generates no traffic is a cancellation. Traffic to a service you are not paying for is someone on a free tier, and free tiers are frequently the ones whose terms allow training on your inputs.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Grep your own codebase
&lt;/h2&gt;

&lt;p&gt;This step takes one command and is skipped constantly.&lt;/p&gt;

&lt;p&gt;Search the repositories for provider SDK imports, model API base URLs, and environment variable names in the shape of provider keys. Then check which of those live in code that is actually deployed, because a proof of concept in a branch is not the same as a production dependency.&lt;/p&gt;

&lt;p&gt;While you are there, check whether those keys are scoped and rotated like your other secrets or whether somebody pasted a personal key into a config file in a hurry. That last one is usually where this exercise pays for itself.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Write the findings as rows, not as a report
&lt;/h2&gt;

&lt;p&gt;Resist the narrative write-up. You want a table that stays current, with one row per service and five columns: what it is, what data reaches it, how it authenticates, who owns it here, and whether it is approved.&lt;/p&gt;

&lt;p&gt;That last column is the one that turns discovery into governance. It only has three honest values: approved, not yet reviewed, and not allowed. A row sitting at "not yet reviewed" for three months is a decision nobody is making, and that is worth seeing on the page.&lt;/p&gt;

&lt;p&gt;Keep the table in version control for the same reasons any inventory belongs there: review, history, and a diff that tells you when something appeared.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Decide what happens the next time, before there is a next time
&lt;/h2&gt;

&lt;p&gt;Discovery is a one-off. The thing that keeps it from being a one-off is a route that is easier than going around you.&lt;/p&gt;

&lt;p&gt;In practice that means two things. A named way to ask, with a response measured in days rather than committee cycles, because a two week approval queue guarantees people will not use it. And a default answer for the low-risk case, so that most requests resolve without a meeting.&lt;/p&gt;

&lt;p&gt;If you want a reference for what the governed end state looks like, &lt;a href="https://irmcon.com/products/ai-governance-playbook/" rel="noopener noreferrer"&gt;IRM's free AI governance playbook&lt;/a&gt; sets out a 90 day plan mapped to NIST AI RMF and ISO 42001, which is a reasonable shape to aim at even if you never certify against either.&lt;/p&gt;

&lt;h2&gt;
  
  
  About IRM's AI Governance services
&lt;/h2&gt;

&lt;p&gt;Disclosure first, so you can weigh the advice accordingly: this post comes from IRM Consulting &amp;amp; Advisory, and the links in it point to our own pages.&lt;/p&gt;

&lt;p&gt;Shadow AI discovery is usually the first week of an AI governance engagement, and it is first for a reason. Every later decision, about acceptable use, about vendor review, about what gets logged, depends on knowing what is already running. Teams that skip it write policies for a company they imagine rather than the one they have.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://irmcon.com/ai-governance/" rel="noopener noreferrer"&gt;IRM Consulting &amp;amp; Advisory&lt;/a&gt; provides AI governance services to SaaS companies, startups and SMBs across Canada and the United States, aligned to the standard frameworks rather than invented ones.&lt;/p&gt;

&lt;p&gt;One question, since the answers split sharply: when discovery turns up a tool a team genuinely depends on and nobody approved, do you switch it off while you review it, or leave it running and review it in place? The first is defensible and the second is what mostly happens.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>devops</category>
    </item>
    <item>
      <title>Your dependency list is not your vendor inventory</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Sun, 01 Nov 2026 13:59:45 +0000</pubDate>
      <link>https://dev.to/irmcon/your-dependency-list-is-not-your-vendor-inventory-jkj</link>
      <guid>https://dev.to/irmcon/your-dependency-list-is-not-your-vendor-inventory-jkj</guid>
      <description>&lt;p&gt;A security questionnaire arrives. Question nine asks you to list every third party with access to customer data. You open package.json, then the AWS console, then the billing export from the company card, and after twenty minutes you realise those three sources disagree with each other and none of them answers the question.&lt;/p&gt;

&lt;p&gt;This is one of the most common gaps on a small team, and it is not a tooling problem. It is that two different lists got collapsed into one. Your dependency manifest tells you what your code imports. Your vendor inventory tells you who can reach your data. Those overlap far less than people expect, and the second one is the list that gets asked for.&lt;/p&gt;

&lt;p&gt;Here is how I would build and keep the second list on a team of ten to fifty engineers.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Two lists, two questions
&lt;/h2&gt;

&lt;p&gt;Write the question at the top of each list so they stop drifting into one another.&lt;/p&gt;

&lt;p&gt;The dependency list answers: what code runs inside our build and our runtime? It comes from package manifests, lockfiles, base images and an SBOM if you generate one. It is long, it is mostly automatable, and its risk is supply chain compromise and unpatched libraries.&lt;/p&gt;

&lt;p&gt;The vendor inventory answers: which organisations outside this company can read, write or infer something about our customers' data, or can reach our production systems? It is much shorter, it is almost entirely manual, and its risk is somebody else's breach becoming your incident notification.&lt;/p&gt;

&lt;p&gt;An npm package with no network calls is on list one and not list two. A support desk tool where agents paste customer records into tickets is on list two and will never appear on list one. Both matter. Only one of them shows up in your repository.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Start from data and access, not from procurement
&lt;/h2&gt;

&lt;p&gt;The instinct is to ask finance for a list of software spend. Do it, because it is a useful cross-check, but do not start there. Free tiers, tools signed up for with a personal card, and anything integrated by an engineer in an afternoon will all be missing.&lt;/p&gt;

&lt;p&gt;Start from the two things that actually define exposure.&lt;/p&gt;

&lt;p&gt;Follow the data. For each place customer data lives, write down everything that reads from it: analytics pipelines, warehouses, BI tools, error trackers that capture request payloads, session replay, email and messaging providers, support tooling, any model or API you send text to.&lt;/p&gt;

&lt;p&gt;Then follow the access. For each production system, write down every external party that holds a credential, a key, a webhook endpoint, an OAuth grant or a role in your cloud account. OAuth grants are the ones teams miss. Someone authorised a tool against the source control organisation in 2024, the tool is still installed, and nobody has looked at its scopes since.&lt;/p&gt;

&lt;p&gt;Cross-check against three sources you already have: the billing export, the identity provider's list of connected applications, and the OAuth or installed-app list in source control and cloud. Where those three disagree, the disagreement itself is the finding.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Four facts per vendor, and resist adding a fifth
&lt;/h2&gt;

&lt;p&gt;Inventories die from being too ambitious. Most teams build a twenty column spreadsheet, fill it in once, and never touch it again. Four columns survive.&lt;/p&gt;

&lt;p&gt;What they hold or can reach. Not the marketing category. Write the actual data: customer email addresses, support ticket contents, production database read replica, nothing beyond aggregate counts.&lt;/p&gt;

&lt;p&gt;How the access works. Federated through single sign on, a long lived API key, an OAuth grant with named scopes, or a human logging in with a shared password. This column tells you how hard revocation will be before you need to revoke anything.&lt;/p&gt;

&lt;p&gt;Who owns it here. One named person, not a team. Ownership with no name attached means nobody renews the review and nobody notices the renewal invoice.&lt;/p&gt;

&lt;p&gt;Whether it touches customer data. A plain yes or no. This is the column that turns a sixty row inventory into the eight rows you actually have to think hard about.&lt;/p&gt;

&lt;p&gt;Everything else, including security certifications and contract dates, can live in the vendor's own folder. Keep it out of the row you need to be able to read at a glance.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Keep it where change already happens
&lt;/h2&gt;

&lt;p&gt;A wiki page is where inventories go to get stale. Put the list in the place your team already touches when things change.&lt;/p&gt;

&lt;p&gt;A file in a repository works well, as a CSV or YAML with one record per vendor, because it gets code review, it gets history, and a diff tells you exactly when a vendor appeared and who added it. You can lint it in CI: fail the check if a row is missing an owner, or if a row marked as touching customer data has no review date.&lt;/p&gt;

&lt;p&gt;If the team will not accept a repository for this, use whatever system already holds onboarding and offboarding tasks. The requirement is not the format. It is that adding a vendor and updating the list are the same action rather than two, because any process where the second one is optional will drift within a quarter.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Make it a side effect, not a chore
&lt;/h2&gt;

&lt;p&gt;Three hooks keep an inventory current with almost no standing effort.&lt;/p&gt;

&lt;p&gt;Add it to the pull request template for anything that introduces a new outbound integration. One checkbox: new third party, inventory updated.&lt;/p&gt;

&lt;p&gt;Add it to offboarding. When somebody leaves, the vendors they personally owned need a new named owner that week, otherwise you accumulate orphaned rows that nobody will claim later.&lt;/p&gt;

&lt;p&gt;Add it to the quarterly access review you are probably already doing for humans. Walk the OAuth grants and installed applications in the same sitting. The question for each is not whether the tool is good. It is whether anyone still uses it, and whether its scopes still match what it does.&lt;/p&gt;

&lt;p&gt;Baseline control sets treat supplier relationships as a control with a register behind it, so if you want a reference for the shape an assessor expects, &lt;a href="https://irmcon.com/products/iso27001/" rel="noopener noreferrer"&gt;IRM's free ISO 27001 gap assessment&lt;/a&gt; walks the supplier controls alongside the rest.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. The subset that becomes public
&lt;/h2&gt;

&lt;p&gt;Some of your vendors are subprocessors: third parties that process customer data on your behalf. If your customer contracts or your own public commitments say you will publish and maintain a subprocessor list, that published list is a subset of this inventory, and it is the subset with an external audience and a change notification obligation attached by contract.&lt;/p&gt;

&lt;p&gt;Practically, that means one more column on the rows where the customer data answer is yes: is this vendor on the published list? A vendor that handles customer data and is not on the published list is either an omission to fix or a decision somebody made and should be able to explain. Both are better found by you than by a customer's legal team.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Reviews that are not questionnaire theatre
&lt;/h2&gt;

&lt;p&gt;Sending every vendor a two hundred question assessment produces paperwork and very little signal, and a small team cannot sustain it anyway. Tier instead.&lt;/p&gt;

&lt;p&gt;For vendors that hold customer data or can reach production, do the real work: read their current audit report or certification scope rather than the badge on their homepage, check that the scope actually covers the product you use, and note their breach notification commitment and your own exit path if they fail.&lt;/p&gt;

&lt;p&gt;For everything else, record the four facts and move on. An inventory that is complete and shallow is worth more than a deep one covering a third of your vendors, because the gap in the deep one is invisible and the shallow one at least tells you where to look.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Test it from outside
&lt;/h2&gt;

&lt;p&gt;Pick a vendor at random from the list and try to prove the row is true. Can the named owner confirm it? Does the access work the way the column says? If the row claims single sign on, log out and see whether a direct password login still works.&lt;/p&gt;

&lt;p&gt;Then run the questionnaire exercise deliberately. Take the last customer security questionnaire you received and answer the third party questions from the inventory alone, with no searching and no asking around. Whatever you cannot answer in five minutes is the part of the list that does not exist yet. That is a cheap afternoon and it is the only honest test of whether the inventory describes your company or describes your intentions.&lt;/p&gt;

&lt;h2&gt;
  
  
  About IRM's Virtual CISO services
&lt;/h2&gt;

&lt;p&gt;Disclosure first, so you can weigh the advice accordingly: this post comes from IRM Consulting &amp;amp; Advisory, and the links in it point to our own pages.&lt;/p&gt;

&lt;p&gt;A third party inventory is one of the things a virtual CISO engagement exists to own. It is unglamorous, it never finishes, and it sits in the gap where most small companies have no one accountable: too much work for an engineering lead who already has a roadmap, not enough to justify a full time security hire. That gap is the whole reason the role exists in a fractional form.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://irmcon.com/virtual-ciso-services-vciso/" rel="noopener noreferrer"&gt;IRM Consulting &amp;amp; Advisory&lt;/a&gt; provides virtual and fractional CISO services to small businesses, startups and SaaS companies across Canada and the United States. Half built vendor inventories are one of the most common findings when we start an engagement, which is why this post exists.&lt;/p&gt;

&lt;p&gt;One question, because the answers vary a lot: when you find an OAuth grant nobody can account for, do you revoke it immediately and see what breaks, or do you chase down an owner first? Both go badly in different ways, and it is worth knowing which way your team would lean before it happens.&lt;/p&gt;

</description>
      <category>security</category>
      <category>devops</category>
      <category>startup</category>
    </item>
    <item>
      <title>Logging for the incident you have not had yet</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Sun, 27 Sep 2026 12:26:59 +0000</pubDate>
      <link>https://dev.to/irmcon/logging-for-the-incident-you-have-not-had-yet-45p2</link>
      <guid>https://dev.to/irmcon/logging-for-the-incident-you-have-not-had-yet-45p2</guid>
      <description>&lt;p&gt;Most application logs are written for the developer who is debugging right now. Incident logs are written for a stranger reading them six weeks later under pressure, possibly a customer's auditor, possibly your own future self at 2am. Those are different jobs, and the second one is the one almost nobody designs for until they need it.&lt;/p&gt;

&lt;p&gt;Here is the shape of the thing that works, at a size a small team can actually build and maintain.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Start from the questions, not from the log lines
&lt;/h2&gt;

&lt;p&gt;An incident is not a search problem, it is an answering problem. There are five questions, and every incident is some arrangement of them:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Who did it? Not the display name, the stable identifier.&lt;/li&gt;
&lt;li&gt;What did they touch? Which specific records or resources, not which endpoint.&lt;/li&gt;
&lt;li&gt;When, in a timeline you can line up across services?&lt;/li&gt;
&lt;li&gt;From where? IP, device, session, API key.&lt;/li&gt;
&lt;li&gt;What changed as a result, and is it still that way?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If your logging cannot answer those five for a given account over a given window, the volume of what you are storing is irrelevant. Work backwards from the questions and you get a much smaller, much more useful set of events than "log everything and buy a bigger plan".&lt;/p&gt;

&lt;h2&gt;
  
  
  2. The minimum event set
&lt;/h2&gt;

&lt;p&gt;For a small SaaS product, this is the list I would want in place before anything else:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Authentication.&lt;/strong&gt; Success and failure, with the reason for failure. Include MFA challenges issued, passed, and bypassed. Include session creation and, importantly, session termination.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Authorization denials.&lt;/strong&gt; Successes are noise at first. Denials are the signal, because a compromised account probing for scope generates them in patterns a human never does.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Privilege and role changes.&lt;/strong&gt; Any change to who can do what, including group membership, including changes made by automation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bulk read and export.&lt;/strong&gt; The single most under-logged event in small products. One record read is a user working. Ten thousand records read is either a report or an exfiltration, and you want to be able to tell which.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Configuration and secret changes.&lt;/strong&gt; Rotations, new API keys, changed webhook targets, changed SSO settings, new OAuth grants.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Integration activity.&lt;/strong&gt; Which token acted, on whose behalf, against which tenant. Third party integrations are where small products quietly get very large blast radiuses.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Admin actions taken on behalf of a customer.&lt;/strong&gt; Support impersonation is a normal feature and a genuine risk. Log it as its own event type, not as the customer's own activity.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That list is deliberately boring. Boring is what you want. Compare it against your own product tonight and you will probably find two or three of these are missing entirely.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Fields that make logs joinable
&lt;/h2&gt;

&lt;p&gt;A log that cannot be joined to another log is an anecdote. Four fields do most of the work:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A &lt;strong&gt;stable actor identifier&lt;/strong&gt; that never changes, alongside the human readable one. Emails get changed, users get renamed, and your six week old logs become unsearchable.&lt;/li&gt;
&lt;li&gt;A &lt;strong&gt;request or trace identifier&lt;/strong&gt; propagated across every service and job that handles the request, including async workers. This is the difference between a timeline and a pile.&lt;/li&gt;
&lt;li&gt;A &lt;strong&gt;tenant identifier&lt;/strong&gt; on every event in a multi tenant system. You will need to answer "what happened in this one customer's account" and you will need to answer it without reading anyone else's data.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;UTC timestamps in a single format&lt;/strong&gt;, ideally RFC 3339. Mixed timezones and mixed formats are how a reconstruction quietly goes wrong rather than loudly failing.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Add the outcome of the action, not just the attempt. "Delete requested" and "delete completed" are different facts.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. What to keep out
&lt;/h2&gt;

&lt;p&gt;This is the part that gets skipped, and it is the part that turns a log store into a liability.&lt;/p&gt;

&lt;p&gt;Logs inherit the sensitivity of whatever you put in them. Full request and response bodies will eventually carry personal data, health data, payment data, or a token. Once that is in a system with wide read access and long retention, you have built a second copy of your most sensitive data with none of the controls you put around the first copy.&lt;/p&gt;

&lt;p&gt;Practical rules:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Redact at the point of emission, not in the pipeline. A redaction step downstream means the raw value existed somewhere, and somewhere is usually a disk.&lt;/li&gt;
&lt;li&gt;Log identifiers, not values. &lt;code&gt;card_id&lt;/code&gt; not the card. &lt;code&gt;user_id&lt;/code&gt; not the email. &lt;code&gt;document_id&lt;/code&gt; not the contents.&lt;/li&gt;
&lt;li&gt;Allowlist what gets logged from a payload rather than denylisting what does not. Denylists fail silently the moment someone adds a field.&lt;/li&gt;
&lt;li&gt;Treat secrets as a build time problem. Scan for token shaped strings in log output in CI, the same way you scan for them in commits.&lt;/li&gt;
&lt;li&gt;Say in writing which categories of personal data are permitted in logs. If nobody has written it down, the answer in practice is "all of them".&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  5. Retention is a decision, not a default
&lt;/h2&gt;

&lt;p&gt;Pick the number on purpose. Two horizons, two different reasons:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Hot, searchable.&lt;/strong&gt; Long enough to investigate something you notice. Thirty days is short for this in practice, because breaches are routinely discovered long after they start.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cold, retrievable.&lt;/strong&gt; Long enough to satisfy the obligation you actually have. That comes from your contracts, your regulator, and your customers' expectations, not from a blog post.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Write down both numbers and the reason for each. An auditor asking about log retention is not really asking for the number. They are asking whether anyone decided it.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Integrity, or why the attacker cleans up after themselves
&lt;/h2&gt;

&lt;p&gt;If the same credentials that run your application can delete your logs, then the logs describe only the incidents your attacker did not care about.&lt;/p&gt;

&lt;p&gt;Cheap version of getting this right, which is within reach for a team of five:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ship logs out of the environment that produced them, to a separate account or project with its own access boundary.&lt;/li&gt;
&lt;li&gt;Make the destination append only, with object lock or the equivalent on the archive.&lt;/li&gt;
&lt;li&gt;Make deletion a separate, logged, alerted privilege held by a small number of named people.&lt;/li&gt;
&lt;li&gt;Alert on the audit log going quiet. Silence is an event.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  7. Test it before you need it
&lt;/h2&gt;

&lt;p&gt;Here is a two hour exercise worth more than another dashboard.&lt;/p&gt;

&lt;p&gt;Pick a plausible scenario. An employee laptop is compromised and their session token is stolen on a Friday night. On Monday, open only your log tooling, no code reading, no database queries, and try to answer the five questions from the first section. Time yourself and write down each point where you had to guess.&lt;/p&gt;

&lt;p&gt;The gaps you find will not be exotic. They will be things like bulk exports not being logged as their own event, or the support impersonation path writing events under the customer's identity, or worker jobs dropping the trace identifier. Every one of those is a small ticket now and a bad week later.&lt;/p&gt;

&lt;p&gt;Do this once a quarter, change the scenario, and let it drive your backlog. That single habit is most of the difference between a logging setup that is expensive and one that is useful. It also happens to produce, almost as a by product, the evidence that the SOC 2 common criteria on monitoring and evaluating security events expect you to have.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Two references worth the time
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;NIST SP 800-92, Guide to Computer Security Log Management. Old, still the clearest articulation of the problem.&lt;/li&gt;
&lt;li&gt;The OWASP Logging Cheat Sheet, for what to log and what never to.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;I work with small SaaS teams at &lt;a href="https://irmcon.com/security-architecture-sa/" rel="noopener noreferrer"&gt;IRM Consulting &amp;amp; Advisory&lt;/a&gt;, and the logging conversation above is one I have had more times than any other. The companion conversation, about what should never end up in a log in the first place, usually turns into &lt;a href="https://irmcon.com/data-security-privacy-dsp/" rel="noopener noreferrer"&gt;data security and privacy reviews&lt;/a&gt; instead. Flagging the affiliation so you can weigh the advice accordingly.&lt;/p&gt;

&lt;p&gt;I am curious about one thing in particular. For those of you who have actually run the exercise in the last section, what was the gap you did not expect to find?&lt;/p&gt;

</description>
      <category>security</category>
      <category>devops</category>
      <category>architecture</category>
      <category>monitoring</category>
    </item>
    <item>
      <title>What a SOC 2 auditor actually asks about your CI/CD pipeline</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Wed, 09 Sep 2026 19:31:29 +0000</pubDate>
      <link>https://dev.to/irmcon/what-a-soc-2-auditor-actually-asks-about-your-cicd-pipeline-4lic</link>
      <guid>https://dev.to/irmcon/what-a-soc-2-auditor-actually-asks-about-your-cicd-pipeline-4lic</guid>
      <description>&lt;p&gt;The first SOC 2 audit I sat in on with an engineering team went sideways in about eleven minutes.&lt;/p&gt;

&lt;p&gt;Not because the pipeline was bad. It was a good pipeline. Trunk-based, tests gated on merge, deploys on green, everything in Terraform. The kind of setup an engineering lead is quietly proud of.&lt;/p&gt;

&lt;p&gt;The auditor asked one question: "Show me that the code deployed to production on 14 March was reviewed by someone other than the person who wrote it."&lt;/p&gt;

&lt;p&gt;Long pause. Everyone knew the answer was yes. Nobody could produce it.&lt;/p&gt;

&lt;p&gt;That gap, between a control that genuinely works and a control you can prove worked, is where most first-time SOC 2 audits burn six weeks they did not budget for. I have watched it happen at companies with far better engineering hygiene than the average. It has almost nothing to do with how secure you are.&lt;/p&gt;

&lt;p&gt;Here is what auditors actually ask, in the order they ask it, and what satisfies them.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Who can push to main, and how do you know?
&lt;/h2&gt;

&lt;p&gt;The control is separation of duties. The evidence is your branch protection configuration plus a population of merges over the audit window.&lt;/p&gt;

&lt;p&gt;What auditors want to see:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Branch protection on your default branch, with required reviews set to at least one&lt;/li&gt;
&lt;li&gt;Force-push and branch deletion disabled&lt;/li&gt;
&lt;li&gt;Admin bypass either disabled, or enabled with an alerting trail for every use&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That last point is where teams lose. Almost every repo has one or two people with admin override, because at some point production was down at 2am and somebody needed it. That is fine. What is not fine is having no record of when it was used.&lt;/p&gt;

&lt;p&gt;Turn on the audit log export before your window starts. On GitHub that is Organization settings, then Audit log, then streaming to your log destination. If your observation window has already started and you did not have it on, you cannot retroactively create it, and you will be writing a management response explaining a gap instead.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Can a change reach production without passing your gates?
&lt;/h2&gt;

&lt;p&gt;Auditors are testing whether your pipeline is the only path to production. Almost always, it is not.&lt;/p&gt;

&lt;p&gt;The usual culprits:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A manual deploy script that someone still has on their laptop&lt;/li&gt;
&lt;li&gt;Direct console or CLI access to the production cluster&lt;/li&gt;
&lt;li&gt;A hotfix workflow that skips the test stage by design&lt;/li&gt;
&lt;li&gt;Infrastructure changes applied by hand outside Terraform&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of these are automatically findings. A documented emergency change procedure with post-hoc review is an entirely acceptable control. An undocumented one that three engineers know about is a finding.&lt;/p&gt;

&lt;p&gt;Write the emergency path down. Say who can invoke it, what approval it needs after the fact, and where the record lives. That one paragraph closes a control most teams fail on.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Show me a change from ticket to production
&lt;/h2&gt;

&lt;p&gt;This is the walkthrough, and it is where the eleven-minute failure happens.&lt;/p&gt;

&lt;p&gt;The auditor picks a date, usually at random, from your deploy history. You need to link, for that one change:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The ticket or issue describing the change&lt;/li&gt;
&lt;li&gt;The pull request implementing it&lt;/li&gt;
&lt;li&gt;The approval, by a different human&lt;/li&gt;
&lt;li&gt;The passing test run&lt;/li&gt;
&lt;li&gt;The deployment record with a timestamp&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Five artifacts, four systems. If your ticket IDs are not in your commit messages or PR titles, you are going to be reconstructing this by hand, per sample, for however many samples the auditor pulls.&lt;/p&gt;

&lt;p&gt;The fix costs about twenty minutes. Add a commit message convention that includes the ticket ID, and enforce it in a pre-merge check. Every subsequent sample becomes a two-link lookup instead of an archaeology project.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. What happens when a dependency has a critical CVE?
&lt;/h2&gt;

&lt;p&gt;Auditors are not asking whether you scan. Everyone scans. They are asking what happens next.&lt;/p&gt;

&lt;p&gt;The control they are testing is vulnerability management, and it needs three things you probably have not written down:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A severity threshold that triggers action&lt;/li&gt;
&lt;li&gt;A remediation window per severity&lt;/li&gt;
&lt;li&gt;Evidence that you met the window, or documented why you did not&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;"We use Dependabot" is not a control. "Critical findings are remediated within 7 days, high within 30, tracked in our issue board with the security label, and reviewed monthly" is a control. The tooling is identical. The difference is entirely in whether you defined the policy before the auditor asked.&lt;/p&gt;

&lt;h2&gt;
  
  
  The pattern underneath all four
&lt;/h2&gt;

&lt;p&gt;Every one of these is the same shape. The engineering practice is already sound. What is missing is the artifact that proves it was sound on a specific date to someone who was not in the room.&lt;/p&gt;

&lt;p&gt;That reframing matters, because it changes what you spend your pre-audit time on. Teams tend to assume they need to build new security controls. Mostly they need to make existing controls legible. Configuration exports, audit log retention, a naming convention, a two-paragraph policy document.&lt;/p&gt;

&lt;p&gt;The teams that clear a first SOC 2 in ninety days rather than seven months are almost never the more secure ones. They are the ones who set up their evidence collection before the observation window opened rather than after it closed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Practical sequencing
&lt;/h2&gt;

&lt;p&gt;If you are three to six months out from your first audit:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Now:&lt;/strong&gt; turn on audit log streaming and set your log retention to cover the full window plus a margin. This is the only item on this list that cannot be fixed later.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;This month:&lt;/strong&gt; write the four documents. Change management, emergency change, vulnerability management, access review. Two pages each is plenty. Auditors read them for existence and coherence, not literary quality.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Next month:&lt;/strong&gt; run a self-sample. Pick three random deploys from the last thirty days and try to assemble the five artifacts yourself. Whatever takes more than five minutes is what will cost you weeks in the real audit.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Ongoing:&lt;/strong&gt; do your quarterly access review and actually date it. Undated access reviews are the single most common finding I see, and the single cheapest to avoid.&lt;/p&gt;




&lt;p&gt;I lead the vCISO practice at IRM Consulting &amp;amp; Advisory, where a good share of the work is walking SaaS engineering teams through exactly this sequence before an auditor is in the room. Our approach to embedding security into delivery pipelines is here: &lt;a href="https://irmcon.com/devsecops-dso/" rel="noopener noreferrer"&gt;https://irmcon.com/devsecops-dso/&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If you are specifically scoping a first SOC 2, we publish the readiness detail at &lt;a href="https://irmcon.com/products/soc2/" rel="noopener noreferrer"&gt;SOC 2 readiness for SaaS&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;What is the control your team found hardest to evidence rather than hardest to implement? I am genuinely curious whether the pattern above holds outside the companies I have worked with.&lt;/p&gt;

</description>
      <category>devops</category>
      <category>security</category>
      <category>cicd</category>
      <category>startup</category>
    </item>
    <item>
      <title>Threat modeling for a team of six: the version that actually gets done</title>
      <dc:creator>IRM Consulting &amp; Advisory</dc:creator>
      <pubDate>Wed, 09 Sep 2026 19:30:24 +0000</pubDate>
      <link>https://dev.to/irmcon/threat-modeling-for-a-team-of-six-the-version-that-actually-gets-done-2afe</link>
      <guid>https://dev.to/irmcon/threat-modeling-for-a-team-of-six-the-version-that-actually-gets-done-2afe</guid>
      <description>&lt;p&gt;Most threat modeling advice is written for companies with a security team. If you are six engineers shipping a product, that advice reads as a list of reasons not to start.&lt;/p&gt;

&lt;p&gt;STRIDE per data flow diagram element. Trust boundary enumeration. A DFD maintained as the architecture changes. Attack trees. It is all legitimate, and none of it survives contact with a team where the person who would run it is also on call this week.&lt;/p&gt;

&lt;p&gt;So teams do the honest thing and skip it, and then the security questionnaire from a prospect asks "do you perform threat modeling?" and someone writes yes and hopes.&lt;/p&gt;

&lt;p&gt;There is a version that fits in one hour and produces something real. I have run it with teams of four and teams of forty. Here it is.&lt;/p&gt;

&lt;h2&gt;
  
  
  The setup
&lt;/h2&gt;

&lt;p&gt;One hour. One feature or service, not the whole system. Three people: whoever owns the code, whoever owns the infrastructure it runs on, and one person who did not build it. That third person is the important one and the one teams skip.&lt;/p&gt;

&lt;p&gt;A whiteboard or a shared document. No tooling.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step one: draw it, badly (10 minutes)
&lt;/h2&gt;

&lt;p&gt;Boxes and arrows. What talks to what. Where does data enter the system, where does it rest, where does it leave.&lt;/p&gt;

&lt;p&gt;Do not make it pretty and do not make it complete. The purpose of the diagram is to give six eyes the same mental model for the next fifty minutes, not to be an artifact you maintain. If it is wrong, someone will say so, and that correction is itself worth the ten minutes.&lt;/p&gt;

&lt;p&gt;Mark three things on it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Every point where data crosses from something you control to something you do not&lt;/li&gt;
&lt;li&gt;Every point where a user-supplied value influences what the code does&lt;/li&gt;
&lt;li&gt;Every place credentials or tokens live&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is your trust boundary map. You did not have to know the term to draw it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step two: four questions (35 minutes)
&lt;/h2&gt;

&lt;p&gt;This is Adam Shostack's framing and it is the most useful thing in the field. Ask, in order:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What are we working on?&lt;/strong&gt; You just drew it. Say it out loud in two sentences. If you cannot, the diagram is wrong.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What can go wrong?&lt;/strong&gt; This is the whole exercise. Go around the diagram element by element. For each one, ask what an attacker who reached this point could do. Not "is this secure." What could they do.&lt;/p&gt;

&lt;p&gt;The prompts that consistently produce real findings in small teams:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happens if this identifier is changed to another tenant's identifier?&lt;/li&gt;
&lt;li&gt;What does this component do if the thing it calls returns garbage, or nothing, or takes forever?&lt;/li&gt;
&lt;li&gt;Who can read this log, and what is in it?&lt;/li&gt;
&lt;li&gt;If this credential leaked today, what is the blast radius and how would we know?&lt;/li&gt;
&lt;li&gt;What does this endpoint do before it checks authorization?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That last one finds more real problems than any other single question I have used.&lt;/p&gt;

&lt;p&gt;Write every answer down, including the ones you immediately dismiss. Dismissing something out loud with two colleagues present is a different act from never having considered it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What are we going to do about it?&lt;/strong&gt; Sort the list into three buckets. Fix now, accept and document, needs more thought. Be ruthless about the middle bucket. Accepting a risk deliberately is a valid engineering decision. Accepting it by forgetting is not.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Did we do a good job?&lt;/strong&gt; Five minutes at the end. Did we cover the diagram. Did anyone hold back a concern. What would we do differently next time.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step three: the artifact (15 minutes)
&lt;/h2&gt;

&lt;p&gt;One page. Date, participants, the diagram photographed or pasted, the findings table with three columns: what could go wrong, decision, owner.&lt;/p&gt;

&lt;p&gt;That page is the deliverable. It is what you point at when a prospect asks whether you threat model, and it is what a SOC 2 or ISO 27001 auditor will accept as evidence of secure design practice, which is a control most small teams have nothing for.&lt;/p&gt;

&lt;p&gt;Do it once per meaningful new service or major architectural change. Not per sprint, not per PR. Perhaps four to six times a year for a team your size.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this deliberately gives up
&lt;/h2&gt;

&lt;p&gt;It is worth being honest about the trade.&lt;/p&gt;

&lt;p&gt;You will not get systematic coverage. Structured STRIDE catches categories of issue that ad hoc questioning misses, particularly repudiation and elevation-of-privilege classes that do not occur to people naturally.&lt;/p&gt;

&lt;p&gt;You will not build a maintained model. The diagram is disposable, so the next session starts from scratch.&lt;/p&gt;

&lt;p&gt;You will be biased toward what the room already worries about. The outsider in step one is the partial mitigation, and it is partial.&lt;/p&gt;

&lt;p&gt;What you get in exchange is that it happens. A threat model that gets run four times a year and finds three real issues beats a rigorous methodology that gets deferred for eighteen months. I would rather argue about the coverage gaps of something that exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  The finding pattern
&lt;/h2&gt;

&lt;p&gt;Across small-team sessions, the same three categories dominate:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Authorization checked after the expensive thing.&lt;/strong&gt; The endpoint fetches, computes, then checks whether you were allowed. Timing and error-message differences leak existence of other tenants' objects.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Trust in an internal service that is not internal.&lt;/strong&gt; Something on the private network is reachable from somewhere it should not be, usually via a path added months after the original design.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Secrets with no rotation story.&lt;/strong&gt; Not leaked secrets. Secrets where nobody can answer what the recovery procedure would be, which means there is not one.&lt;/p&gt;

&lt;p&gt;None of these require a specialist to find. They require an hour and someone asking the second question.&lt;/p&gt;




&lt;p&gt;I run the vCISO practice at IRM Consulting &amp;amp; Advisory in Toronto, working with SaaS and scaling teams on exactly this problem: security practices proportionate to the size of the team actually doing them. Our threat modeling approach for small engineering teams is written up at &lt;a href="https://irmcon.ca/threat-modeling-tm/" rel="noopener noreferrer"&gt;https://irmcon.ca/threat-modeling-tm/&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If the constraint is that nobody owns this work rather than that nobody knows how to do it, that is the gap fractional security leadership is meant to fill. Detail here: &lt;a href="https://irmcon.ca/virtual-ciso-services-vciso/" rel="noopener noreferrer"&gt;https://irmcon.ca/virtual-ciso-services-vciso/&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Curious what the third category is for other people. If you have run a session like this, what kept coming up that is not on my list?&lt;/p&gt;

</description>
      <category>security</category>
      <category>architecture</category>
      <category>startup</category>
      <category>webdev</category>
    </item>
  </channel>
</rss>
