<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Adam Hutton on Medium]]></title>
        <description><![CDATA[Stories by Adam Hutton on Medium]]></description>
        <link>https://medium.com/@adamhutton?source=rss-b4ba316c8325------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wV6VLRDJICfSkMLAFY_U-A.jpeg</url>
            <title>Stories by Adam Hutton on Medium</title>
            <link>https://medium.com/@adamhutton?source=rss-b4ba316c8325------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 15:53:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@adamhutton/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Prototyping a graph db-based CMDB]]></title>
            <link>https://adamhutton.medium.com/prototyping-a-graph-db-based-cmdb-92df1aab35e0?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/92df1aab35e0</guid>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Tue, 07 Oct 2025 10:30:49 GMT</pubDate>
            <atom:updated>2025-10-07T10:30:49.312Z</atom:updated>
            <content:encoded><![CDATA[<p>&amp; some fun with Claude Code…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*17DVi-KEGEJBhsPrERL1UA.png" /></figure><p>It’s been a while since I’ve had the idea of working with a graph database to model a CMDB. The node/edge structure seemed like a perfect fit to more efficiently define and travel correlations.</p><p>This seemed like a good first project to really dive in to Claude Code and its ability to generate apps that support mock data generation in the ITOM/ITSM-space.</p><h3>In a nutshell</h3><p>I built an app — an experimental CMDB that runs on Neo4j instead of a traditional relational database. More accurately, I’ve been prompting Claude Code to build the app and I’ve just been reviewing, adding fixes, adjusting development, etc. The results are pretty good as a framework, but there’s lots of room for improvement.</p><h3>The process:</h3><ul><li>Use Claude Opus just for the ideation phase. This more advanced reasoning model consumes a lot of tokens, but is helpful to build a small corpus of research and analysis in trends of observability, ITOM, cyber vulnerability scanning and other tooling. This built a conceptual framework for combining these objectives into a more advanced ‘goals’ in prompt structuring to Claude. Below is my sample prompt to get the ball rolling (this is after doing an /init to create the basic project folder and documentation).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TBtsT1OrMHqGxMmiWJSpNg.png" /><figcaption>Initial prompting to build a set of objectives and provide claude code with context on the topic</figcaption></figure><p>This was just the start, I used a number of additional prompts, including triggering deep research to dig into related material and pull it in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n6zsJcAxlv_-CYRVCroSoA.png" /></figure><p>Some more background prompting…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lb26ia5cg1eNAz7J192YLQ.png" /><figcaption>What are trends in application observability related to IT Operations?</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Shtdpyohhq6mmZT9kBX65A.png" /><figcaption>What are patterns for relationship correlation?</figcaption></figure><p>I had lots of research prompts in the interim to just build a corpus of ITOM/CMDB/ITOM context information for the LLM.</p><p>This background information gave me a lot to work with for ‘art of the possible’ in a CMDB demo. Now on to building it.</p><h3>Building a mock CMDB app</h3><p>I started with several prompts to build the skeleton of the application, then enrich the various features. The results are VERY buggy but roughly coherent. It scaffolded the below architecture for the app:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KzA91lrvnWaBnT4yW8YNqQ.png" /><figcaption>Basic architecture of the app.</figcaption></figure><p>I don’t really need a mobile app or external APIs, nor load balancing, but I appreciate that it put them there as placeholders. I suspect this is because most app architectures these models are trained on always include these.</p><p>It all runs in Docker, albeit somewhat slowly. Which I’m working on to figure out some performance improvement opportunities later.</p><p>I haven’t worked out scaling yet or load balancing, that’s on the backlog for the future.</p><p>From the basic scaffolding of components, it did a decent job at a UI — but nothing really <em>worked </em>per se. It looked decent, but there were a lot of places that weren’t quite coherent or functional. So LOTS more prompts to make the various parts operate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TB1dRh-ytJki0Ga5" /><figcaption>Initial loading screen</figcaption></figure><p>One thing that’s nice, if you’re working on debugging things — just add debuggers! Claude proved very good at building out test coverage, re-running it, cleaning it up. But it helped to <em>tell it </em>to build in more debuggers and logging to track how the app is working. Now, I probably have the opposite problem of too many different debug features in the code.</p><h3>Results of the application design and learnings</h3><p>Along the way, this process taught me a few things:</p><ul><li>Build your application specs in /docs as a set of markdown files — I feel like these are the make or break design components. All the generated code aside, the part that matters is having the agent continually update and refine its documentation. Sometimes it does this on its own, often I had to remind it to go through and update all the documentation. Unfortunately, this ate a lot of tokens space (I’m only on a pro account), but makes for faster debugging and a more reliable app.</li><li>AI coding tools are impressive at design and rough structuring; it adds a lot of fun back into the coding process. I spent much more time thinking about what I wanted to do rather than how to code it — for better or worse.</li><li>I’m not used to the disconnect that I feel not having written every line. There’s still part of me that wants to know how it all works — though not enough to actually sit and read through everything. I’m getting over this simply by being able to progress so much faster on exploratory apps that I’m not planning to rely on in any kind of production setting.</li><li>Multiple agents — copilot and Claude, for example, can work together to check for code quality, security, performance and other issues. Even the GitHub code scanning found some issues which I’ll work on fixing soon.</li></ul><p>Overall, this is great for experiment building and iterating on a design concept. For building a production-grade system, this would merit a different approach entirely. I’d still strongly recommend using ai agents to build, write, co-author, etc. code, but at a much different pace.</p><p>Try the app out for yourself: <a href="https://github.com/admhttn/graphdbcmdbconcept">https://github.com/admhttn/graphdbcmdbconcept</a></p><p>Feel free to contribute, raise issues, feature requests or bugs that you find!</p><p>Screenshots are here:</p><p><a href="https://github.com/admhttn/graphdbcmdbconcept/wiki/Screenshots">Screenshots</a></p><p>Note that i’m actively updating it and working on enriching the features. I’m able to generate a million or so CIs and relationships pretty quickly; however, the correlation engine still has lots of bugs.</p><p>Here are some more screenshots:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ExMgP9OIwdpg4BkK0mpmog.png" /><figcaption>A simple topology view</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HwWZWp86qccDUFqCcti2XQ.png" /><figcaption>Sample demo scenarios</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JejwGBLi-TrV3xy6E4yaLQ.png" /><figcaption>Demo features to compare traditional SQL querying with Neo4j queries</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92df1aab35e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jumping into Agent Design]]></title>
            <link>https://adamhutton.medium.com/jumping-into-agent-design-56d305ad9150?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/56d305ad9150</guid>
            <category><![CDATA[ai-agent-development]]></category>
            <category><![CDATA[servicenow]]></category>
            <category><![CDATA[servicenow-platform]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Wed, 09 Jul 2025 00:40:43 GMT</pubDate>
            <atom:updated>2025-07-09T00:40:43.671Z</atom:updated>
            <content:encoded><![CDATA[<p>AI Agents are fascinating and building them is unlike anything I’ve developed before. I suspect most others across platforms are experiencing a similar feeling. This article is just a start on some musings around the experience in just the planning and design phase.</p><h3>How many agents do I need?</h3><p>I’ve been starting to work with ServiceNow’s AI Agents and digging into agent sizing and complexity. Too big and complex an agent’s tasks are, it gets too easy to hit their context limits and it becomes easier to make mistakes. Too small of agents and you have a coordination problem — agents don’t know what the others are doing, they may result in conflicting outputs.</p><p>This had me thinking of a few analogies outside of tech:</p><ul><li>How the brain itself coordinates tasks</li><li>A brigade system in a Michelin-star restaurant</li><li>A conductor leading an orchestra</li></ul><p>Each of these has a set of specialized functions to perform but absolutely must coordinate their work together for the whole thing to work.</p><p>If you happen to work in any of these fields, please excuse the trivial nature of these analogies. In each field, there’s depth and nuance here that I’m lacking — but feel free to comment. <em>I, in no way, claim to be an expert any of the below fields.</em></p><h4>The human mind</h4><p>Analogy: The human mind behaves like a federation of specialized sub-processes (“agents”) — language processing, motor planning, memory retrieval, etc. Each module works semi-independently, yet coordination is achieved through:</p><ul><li>Global Workspace Theory: A shared “workspace” (working memory) where modules publish important information for others to access.</li><li>Attention: Acts as a prioritization mechanism — “broadcast this signal,” “suppress that distraction.”</li><li>Inhibition and Excitation: Competing actions (e.g. reaching vs. holding back) dynamically resolve in the motor cortex via feedback loops.</li></ul><p>AI takeaway: Emulate this with a shared memory store or event bus where agents can publish goals, intermediate results, and status updates, and selectively read based on their role.</p><p>I particularly like this one, so from just a bit of reading on more ways in which the brain operates, there are:</p><ul><li>Short-term memory buffers (working memory) to “hold” current goals/results.</li><li>Re-entrant loops — multiple processes accessing shared state (via thalamus, hippocampus, etc.).</li><li>Attention-based gating — to route what’s relevant to the right subsystem.</li><li>Conflict resolution — like the basal ganglia inhibiting one motor action in favor of another, based on competition and reinforcement learning.</li></ul><p>In software: This might resemble vector databases, event-based messaging (like Kafka or Redis streams), or a blackboard system, with agents trained to “attend” only to relevant features or events.</p><h4>A restaurant’s brigade system</h4><p>Analogy: A top-tier kitchen runs on the Brigade de Cuisine system (Escoffier’s model):</p><ul><li>Clear roles: Executive Chef (vision), Sous-chef (coordination), Line cooks (execution).</li><li>Ticketing system: Orders (goals) are broadcast visually/audibly.</li><li>Synchronization points: The expediter (chef de passe) coordinates plating — timing is crucial.</li><li>Low chatter: Communication is mostly status signals (“heard!”, “on fire!”) — very terse but informative.</li><li>Shared mental model: All staff know the menu and the ideal output at any time.</li></ul><p>AI takeaway: Implement agent roles, a shared task queue, status signals, and a “plating” stage where outputs must be aligned before release. Real-time awareness can be based on explicit “state signals” rather than deep messaging.</p><h4>An orchestra</h4><p>Analogy: Each musician is autonomous and skilled, but:</p><ul><li>Score = Shared plan: Everyone works off the same “script.”</li><li>Conductor = central attention agent: Not micromanaging, but setting tempo, transitions, and emotion.</li><li>Timing &amp; Feedback: Musicians rely on:Visual signals from conductor.</li><li>Auditory feedback from nearby players.</li><li>Internalized timing models.</li><li>Tuning before performance: They agree on a “global state” (key, tuning) in advance.</li></ul><p>AI takeaway: Combine decentralized execution with centralized tempo/orchestration control. Agents can “hear” each other’s state via shared logs or vector representations, but must also maintain an internal model of timing/progress.</p><h4>Practicality of all this</h4><p>To be determined. This is leading me to revisit some old books on Cybernetics and coordination theory. Also, some old books on my shelf from early management theory. Back when coordination of work discounted the human part of separation of tasks in favor of segmentation of labor strictly along the lines of pointed skill application and efficiency of action.</p><h4>Doing some of this in ServiceNow</h4><p>Immediately, I don’t see a way to dynamically write or provide-back cues of work or completion between agents in the AI Agent Use Case builder. I may have to think about an agent that can write to a scratchpad or to a section of a case / task record itself.</p><p>Admittingly, for now, the agents I’ve built aren’t complex enough to really test this out. So off to designing some overly complex ones just to try to run some evaluations!</p><p>There’s a few documents and articles that I’ve found helpful so far:</p><iframe src="https://drive.google.com/viewerng/viewer?url=https%3A//cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf&amp;embedded=true" width="600" height="780" frameborder="0" scrolling="no"><a href="https://medium.com/media/bfdfe2a47e36ae144437fa4b8d2fe316/href">https://medium.com/media/bfdfe2a47e36ae144437fa4b8d2fe316/href</a></iframe><ul><li><a href="https://cognition.ai/blog/dont-build-multi-agents">Cognition | Don&#39;t Build Multi-Agents</a></li><li><a href="https://www.anthropic.com/engineering/building-effective-agents">Building Effective AI Agents</a></li></ul><p><a href="https://direct.mit.edu/books/oa-monograph/4581/Cybernetics-or-Control-and-Communication-in-the">https://direct.mit.edu/books/oa-monograph/4581/Cybernetics-or-Control-and-Communication-in-the</a></p><ul><li><a href="https://github.com/Shubhamsaboo/awesome-llm-apps/tree/main">GitHub - Shubhamsaboo/awesome-llm-apps: Collection of awesome LLM apps with AI Agents and RAG using OpenAI, Anthropic, Gemini and opensource models.</a></li><li><a href="https://newsletter.victordibia.com/p/10-ways-to-compare-and-select-the">10 Ways to Critically Evaluate and Select the Right Multi-Agent Framework</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56d305ad9150" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The enterprise [promise|terror] that is Agentic AI]]></title>
            <link>https://adamhutton.medium.com/the-enterprise-promise-terror-that-is-agentic-ai-3f78a337335a?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f78a337335a</guid>
            <category><![CDATA[servicenow]]></category>
            <category><![CDATA[it-service-management]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[genai]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Thu, 10 Apr 2025 11:41:04 GMT</pubDate>
            <atom:updated>2025-04-10T12:05:17.033Z</atom:updated>
            <content:encoded><![CDATA[<h3>The IT Ops [promise|terror] that is Agentic AI</h3><p>AI Agents promise to remove the rigidity of traditional RPA bots. How do enterprises get ready managing control, oversight, or — at least — awareness of these semi-autonomous agents roaming your network?</p><blockquote>Coming soon is a period of time where AI Agents and IT Operations will need to play nicely together for production use cases. This article attempts to provide some background, analogies, and paths forward for this quickly approaching period of time. I try to frame it in context of traditional ITSM as the starting point of reference.</blockquote><blockquote>IT Ops. must take tactical steps to stay relevant in the period of time before various Agent management frameworks go from academic and research to on the ground operational execution within IT shops.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*exTaG8WeyGvvikGh" /><figcaption>Photo by <a href="https://unsplash.com/@dinah1mengtx?utm_source=medium&amp;utm_medium=referral">Dinah Liu</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Setting the scene</h3><p>Traditional ITSM-based IT operations have always struggled with the edge or encroaching technologies, in favor of the fixed and stable objects to manage. Think about a few buckets of technology that IT is typically good at maintaining: physical hardware — servers, network devices, ESX hosts. It took years to perfect discovery against these classes of devices, even today many organizations struggle with managing discovery credentials, identification and reconciliation, and a host of other data challenges.</p><p>From here, it moves into a gradient, harder to maintained but there’s significant effort thrown into it: business applications, component relationships and dependencies, software license allocations.</p><p>Then we run into the questionable to maintain — the transient objects. Things like service accounts, certificates, kubernetes nodes, autoscaling services and traditional RPA bots.</p><p>Note that I haven’t started talking about logical service definitions. I’d put those a step higher of effort to maintain. These are assemblages of components, services, APIs, resources, etc. that make an application perform some function. Nearly always, these records are maintained by hand.</p><p>There’s the other direction not often filled by the CMDB, that’s the makeup of the applications themselves. Knowing what libraries, packages, dependencies were used to build an application. This is something that revealed itself to many IT departments back in 2021. Traditional CMDBs were left lacking in richness to provide rapid response to address this — they didn’t know how the apps were built.</p><p>Lastly, there’s the nature of the relationships themselves. IT’s challenge over the years has been around building semi-static relationship maps to indicate what runs on what down the stack. Transient CI records challenged this — the often batch processes of discovery don’t lend well to the continually dynamic nature of these types of resources.</p><p>We’ve come a long way building and maintaining rich CMDBs, but many of the fundamentals still prove challenging for any IT organizations focused only on infrastructure discovery to populate their CMDB.</p><p>Why am I brining this all up? An entire new demand channel, Agentic AI, is hitting the stage for IT to either lead in governing and maintaining — or to secede this responsibility to other functions.</p><p>To summarize, traditional CMDBs, and the IT Ops teams they serve, struggle with:</p><ul><li>Transient, rapidly changing resources</li><li>Logical service definitions — composites that link together related lower-level components</li><li>The bill of materials that make up applications — their libraries, dependencies</li><li>The relationships between all of these — keeping these up to date</li></ul><p>Because of the above, ITSM processes tend to rely less on the CMDB than they ideally should. Again, this is getting better — and some IT shops do it really well — but this has been a long, 20 year journey that’s still going on.</p><blockquote>IT, ITSM and IT Ops is often starting off on the back foot. For more on the challenges with ITSM and the CMDB, check out my other article: <a href="https://adamhutton.medium.com/itsm-asset-management-and-the-cmdb-know-who-your-customers-are-0a573b8f4a3c">ITSM, Asset Management and the CMDB: Know who your customers are</a></blockquote><h3>Agentic AI’s Push Against Traditional IT</h3><blockquote>The 2023–2024 GenAI buzz was a canary in the coal mine for IT. 2025 will be another exploratory year for AI Agents, likely most being POCs or point-specific use cases. At this rate, by mid-2025, 2026–2027 we’ll be past the tunnel’s end, in the pits, and listening for timbers cracking.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bitRkla4RI5_LAWw" /><figcaption>Photo by <a href="https://unsplash.com/@design_maffeisluca?utm_source=medium&amp;utm_medium=referral">Luca Maffeis</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Where GenAI provided insights and excitement in 2023–2024, these applications were still very traditional — they augmented capabilities in existing application. Or GenAI apps were just that — a GenAI chat window with maybe some grounding or contextualized content powered by an off the shelf LLM. AI Agents, on the other hand, will execute tasks — just like micro-services or traditional RPA, they will serve to take action and execute workloads.</p><blockquote>ITSM frameworks need to account for not just interdependencies, but collaborations across agents</blockquote><p>For now, I want to focus on how AI Agents represent a new dimension in IT attempting to track. Take one look at the AI Agent Marketplace: <a href="https://aiagentsdirectory.com/categories">https://aiagentsdirectory.com/</a> and you can see the sprawl and pace of new agents being released. New startups are being launched pitching their agents of the future, and existing players — like ServiceNow — releasing their own storefront of AI Agents.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JkYFfOPT3E2EQeYlg-0Lpw.png" /><figcaption><a href="https://aiagentsdirectory.com/categories">https://aiagentsdirectory.com/categories</a> retrieved on 4/8/2025</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aBdscUc3_uOxoCKC6va1qw.png" /><figcaption><a href="https://store.servicenow.com/store/ai-marketplace">https://store.servicenow.com/store/ai-marketplace</a> retrieved on 4/8/2025</figcaption></figure><h3>Solving the Challenge with Tech: Rise of the frameworks</h3><p>Good news in that we are not for a lack of development being thrown at the management challenge. The first thing in the market to try and address this are interoperability frameworks and runtime platforms. Many of them. Microsoft Semantic Kernel and Autogen, LangGraph, CrewAI, Google Agent2Agent (A2A) and Model Context Protocol. Just like the early days of cloud computing, these will shake out over the next few years to what should become a few interoperability and definition standars.</p><p>Probably the least technical and the most corporate of the bunch is Google A2A. In this, what I’m happy to see is the Agent Card descriptive component. Similar to model cards for LLMs, this should help any future cataloging system interrogate and at least understand the agent — even if it doesn’t always help them know where it is running in production or what it is interacting with. It is at least consistency in defining the service asset-side of the equation, to throw an old ITIL term out there.</p><blockquote>A bright spot: Google releasing the A2A Protocol, with sign-on by ServiceNow, KPMG, and a host of other organizations.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9Uk8jHQFbSrY-f3Q.png" /><figcaption>Google A2A Protocol, sourced 4/9/2025 — <a href="https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/">https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/</a></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gx3HXbPgSEozx7bcznqSJA.png" /><figcaption>An A2A Agent Card, Google Agent2Agent, <a href="https://google.github.io/A2A/#/documentation?id=agent-card-1">https://google.github.io/A2A/#/documentation?id=agent-card-1</a> Retrieved on 4/9/2025</figcaption></figure><h3>A path forward for humans: Agent Ops</h3><blockquote>Could this be a HR for AI Agents?</blockquote><p>Leaving the technology enablers to the side — there’s still the question, what are people doing in relationship to these agents. How will traditional ITSM processes scale and adjust to AI agents making autonomous skill, goal and choice-based reasoning to execute work. The traditional definition of an incident involving a real or potential interruption to service seems a little out of date.</p><p>A failure of an AI Agent may cause an incident, but it is likely to cause something more benign — less immediately dramatic than a service outage. Instead, a misbehaving agent may be performing poorly against its desired goal. The agent’s capabilities are mis-defined. The prompt needs to be adjusted — the agent itself may need split into sub-agents that, given whichever LLMs are powering them, are more suited to the job.</p><p>This is starting to sound a little like HR, without the PII. Agents that are poor performers need to have their prompts and groundings re-evaluated, adjusted, or even be removed.</p><blockquote>Could we put a sub-optimally performing on a performance improvement plan?</blockquote><p>While this is fun to think about, let’s go back to what’s practical. We’re not likely to invent a new tranche of IT processes, I don’t think we need them. What we do need to do is make our current ones more robust and expansive. Our current frameworks provide us the bones, I’m suggesting we add new meat to them</p><p>Observability platforms will strive to detect bias or inefficiencies, but may not trigger halting of the service. This would be the case of showing statistical drift, but not yet failing in their goal. For example, if a fraud case correlation agent were required to show 100% or better accuracy relative to a trained NLU similarity model and normally operated at 109% accuracy, trending to 107% likely wouldn’t halt the model from usage.</p><p>We can do this in ITOM, Event, and AIOps.</p><h4>Information About a Misbehaving Agent</h4><p>If this were a server misbehaving, we’d capture event data in IT Operations Management, still very similar to traditional ITSM in its pipeline. A quick sketch is below. I’m placing some additional emphasis on things like EA and standards — these are all good things to do in infrastructure-land, but we’ve been building them up for 20+ years. AI Agents is a whole new game — new tools, new frameworks, new platforms, etc. Your people-agents are going to need clear, easy to access guidance on what to use where. Because everything is changing so quickly, you’re going to need to version control what was acceptable and when, so agents deployed six months ago on a phased out framework are tracked accordingly. Again, all things that are good and normal to do in traditional apps and infrastructure, but this new class of AI will pressure test how good and clear those processes are today.</p><blockquote>How well published, clearly documented, version controlled, tracked and tagged are your current EA standards provided to apps and infrastructure being deployed today? AI Agents will pressure test all of these, at once, and very quickly.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NmdMJZS5rbovr3vTzL249Q.png" /><figcaption>Rough sketch on a misbehavin&#39; Agent</figcaption></figure><p>One thing that I’m adding here is the supplemental content related to context in which the AI was run. This is where something like A2A can help by defining a framework for the content that should be captured between agents interacting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kq7pgzkTekRz0vH9GUwiTA.png" /><figcaption>Example supplemental content to capture between agents communicating and executing work</figcaption></figure><p>I used mostly A2A for the bullets above, but in MCP, there are similar information sets related to prompts, resources, tools, transports, etc. that would also provide information. At least MCP uses common lingo — Hosts, Clients, Servers, Data Sources!</p><p><strong>Supplemental content</strong> here is the critical difference. Going way back to the beginning, <strong>ITSM has always challenged with transient objects and knowing what was vs. what is. CMDBs don’t do a great job at capturing resources that are spun up and shutdown in quick succession</strong> — back to their batch job nature. With physical servers and network gear — this didn’t happen. With traditional VMs, it was faster but still managable. With Kubernetes and containerized infrastructure — it is MUCH faster, but luckily (for IT, at least) not <em>that </em>many enterprise apps utilize rapid scale-up / scale-down actions.</p><p>Agents are <em>all</em> going to be defined by their context and actions. Their execution steps will change based on the environment they’re exeucting them against. An AI Agent taking action autonomously on a website to perform an action is evaluating that website at the time of its running and making a decision to click on [x,y] because that’s where it believes the ‘submit’ button is. That may change as the agent changes, as the inputs change, as the target website changes, etc.</p><p>To diagnose that an agent is going awry, the context will be key. Analyzing the context in conjunction with the action and outputs will also be key — also using GenAI to make sense of this will be the only way this will be able to scale.</p><h4>Tying this all together and where is it going?</h4><p>The good news is that the crux of these processes are found in what we already should be doing in IT. Concepts like technical services, service assets, incident patterns, are all things that have been around since ITIL v3 (maybe v2, even). The challenge next is pinpointing how this entirely new class of objects is going to flow through those same processes.</p><p>There’s a few themes that I predict will be converging and I’ll relate these to features in the ServiceNow platform:</p><ul><li><strong>Zero Copy Connectors (Workflow Data Fabric)</strong></li></ul><p>This is going to be way too much data to attempt to batch feed into ServiceNow. The old ways of batch discovery might still be useful for querying repositories and seeing what is out there. But for the actions taken by agents, the context of that action, and other point in time details, this is going to need to make use of in place or dedicated data services, such as Snowflake or Databricks. This data is also going to be used by lots of other consumers, so copying it into your ServiceNow environment likey won’t make practical sense or be performant enough.</p><ul><li><strong>AI Agents for IT</strong></li></ul><p>The speed of everything above is going to require AI to make sense of it, to build those controls, and build those policies. AI Agents are going to be critical for your humans to be able to incorporate and make sense of all of this Agent actions and supplemental data.</p><p>Also, GenAI can make this easier — it can coach, guide, inform, contextualize information for your humans working to make sense of it. The Tier-1 Service Desk Agent in your organization has likely never seen an incident caused by an Agent, let alone tried to analyze an incident raised by one! Early on, these incidents will be pushed right away to Tier-2 or engineers more familiar with it. That’s going to be very expensive — so just like any other first line support call, you’ll want to move these to Tier-1. (We could talk later about a Tier-0 self service for AI agents, which would be a whole new article!)</p><p>Use AI Agents to help your engineering and service desk teams handle these.</p><ul><li><strong>AI Governance and Automation of those Controls</strong></li></ul><p>Traditionally, IT Governance has been assessment based and reactive. Everything above is going to require that AI Governance take a faster, more involved role alongside IT operations. Many AI observability, discoverability, and evaluation tools in the market (Hidden Layer, Wiz, Arthur Shield, etc.) are making big strides in this front. But often they’re disconnected from IT Ops. These classes of tools will be critical when applying the contextual information needed to evaluate and diagnose an agent.</p><p>IT Ops people, make friends with your Governance teams. Traditionally this has been an audit/checklist exercise. They’re going to be looking at ways to automate their controls, free up time to devise new automated controls against AI services. They’re chasing as fast of a moving train as the IT-side of the house is. Luckily it is the same train being chased and many of the datasets both sides are working on are complimentary to each other.</p><p>If you’re still using legacy tools — or manual spreadsheets! — for tracking your compliance, start looking at tools like ServiceNow’s IRM suite, especially the automation side of it.</p><p>This all will keep moving quickly. The frameworks will shake out and live running agents will go fast and likely break a few things, but we went through this when cloud computing first became a thing, when DevOps wanted to do CI/CD pipelines. Let’s look at those lessons as preparation for this one!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f78a337335a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ServiceNow from A to Z, Relics from the past: CI to Group Relationships]]></title>
            <link>https://adamhutton.medium.com/servicenow-from-a-to-z-relics-from-the-past-ci-to-group-relationships-dc1c172e7242?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc1c172e7242</guid>
            <category><![CDATA[servicenow-development]]></category>
            <category><![CDATA[servicenow]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Mon, 07 Apr 2025 02:52:11 GMT</pubDate>
            <atom:updated>2025-04-07T02:52:11.045Z</atom:updated>
            <content:encoded><![CDATA[<p>This is part of a series. Looking at the last alpha release until we start over, exploring some of the in-instance time capsules.</p><h3>How do you link CIs to Groups?</h3><p>Most organizations today use either fixed attributes on the base or specific CI record to indicate who provides what level of support to a given CI. Sometimes this is inherited down based on higher order service definitions, or other upstream components the CI is running on. Sometimes this information is mapped via Dynamic CI Groups or translated via Cloud Resource Tagging.</p><p>But, there was an old way to do this. Back in Remedy-days, we could build Supported By (Tier 1), Provides Approval For, Escalation Tier 2 Support, Owned by, Managed by, Upgraded by… you get the idea, relationships in any manner we pleased. This capability was built into ServiceNow’s CMDB with the cmdb_rel_group table. This simply relates a CI to a Group and gives it a purpose. It is a forgotten stepchild to the cmdb_rel_ci table, which is the most common mechanism to define a relationship amongst infrastructure and application-level CIs.</p><h3>Also related, CMDB to User Relationships</h3><p>Not to also be forgotten, there is a cmdb_rel_user table. Just the same as the CI to Group relationship, this lets you define a similar mapping between a CI and a User.</p><h3>Good Practice but Challenging Maintenance</h3><p>These two tables are both theoretically the right way to build a relationship between CIs, Users, and Groups. They’re faster to query (if setup properly) and allow for quick expansion to different reasons for the linkage. If you could dream the nature of a relationship, you could add it to your hearts content.</p><p>But the flexibility is rarely needed. There’s very little reason to build so many reasons for linking either of these to a CI. This is where it is just more practical to have a few fields directly on the record. Much simpler maintenance, simpler querying, simpler use elsewhere in the platform. By avoiding these relationship tables, you avoid a glide record lookup every time you’re looking to consume it. You also avoid the overhead to maintain the relationships — especially removing old ones, something often forgotten to do in Remedy implementations that used these.</p><h3>How should you be doing it today?</h3><ul><li>Great: Dynamic CI Groups</li><li>Okay: Horizontal walking to CI Class information</li><li>Well intentioned but confusing: Horizontal walking to Class &amp; Other information (e.g., via a Decision Table)</li><li>Best: Technical Service Definitions</li></ul><p>All of these methods will prove much easier to maintain over time compared to relationship tables. Theoretically, those relationship records are great — if you build the features to maintain them, they can be. But for everyone else, keep it simple!</p><p><a href="https://www.servicenow.com/docs/bundle/yokohama-platform-security/page/administer/security/reference/r_CIRelationshipsAndHistory.html">Product Documentation | ServiceNow</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc1c172e7242" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ServiceNow from A to Z, Relics from the past: the ticket table]]></title>
            <link>https://adamhutton.medium.com/servicenow-from-a-to-z-relics-from-the-past-the-ticket-table-d5077b5733f0?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/d5077b5733f0</guid>
            <category><![CDATA[servicenow]]></category>
            <category><![CDATA[servicenow-developer]]></category>
            <category><![CDATA[servicenow-development]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Mon, 07 Apr 2025 02:16:14 GMT</pubDate>
            <atom:updated>2025-04-07T02:16:14.726Z</atom:updated>
            <content:encoded><![CDATA[<p>As we get close to Zurich, fully through the ServiceNow alphabet, I thought it’d be fun to check out some of the legacy features still hanging around.</p><p>One of the relics from pre-Aspen ServiceNow is the ‘ticket’ table. This extends task, but isn’t used anywhere. Where did it come from? What was it used for?</p><p>It extends Task. But, that’s it. It exists without any new columns, no related lists — nothing references it. If a client brings it up to me, I laugh a bit and tell them — no, we’re not using that table for [x] use case. We’re not using it for any use case.</p><p>Over the years, I’ve seen it used to:<br> — Track HR cases (usually, before HRSD was released)<br> — Record customer calls (before interactions or the New Call Wizard)<br> — Too many than I’d like to count — custom use cases, where organizations didn’t want to incur a new custom table count.</p><p>Every one of these scenarios ended up moving over to a legit table, anyhow, purely for better functionality that comes with designing a proper data model.</p><p>Finally, today, it’s been years since I’ve last seen it in use or heard of it brought up. Occasionally an intrepid young developer asks a ‘hey, could we use…’ and I just chuckle a bit.</p><p>My best hypothesis is that it came out of HP Service Manager or Remedy’s mechanisms for handling interactions / phone call tracking. When we integrate with an ACD telecom system, such as Genesys, we need to record the call log for help desk call tracking.</p><p>Back before Interaction records, we still needed something to track these. The New Call Wizard wasn’t actually a record (initially, later versions created a legitimate record before proper Interactions were released). This record allowed start/end phone logs (via custom fields), a pre-incident or request record to be instantiated before the contents of the call were determined, and a record of past calls with the customer when reviewing the ultimate case/incident/request record.</p><p>Yes, if you’re not using Interactions, ServiceNow out of the box expects you to create a new Incident on-call then transfer to a Service Request. This works technically fine — but for the ITIL purists, made us all gag a bit. The call isn’t necessarily reporting an interruption in a service! They could be asking for a password reset — which, subject of way too many debates, firmly sits in the bucket of Request Fulfillment. (I even remember some uber-ITIL purists saying that it should be a standard, pre-approved Change Request, but I don’t recall ever once seeing something like this in practice.</p><h3>What should you be doing today?</h3><p>Interactions. These continue to be enhanced, even today with Yokohama introducing new features in Service Operations Workspace for displaying recent tasks upon a new Interaction record being saved.</p><h3>Where to go tomorrow?</h3><p>With AI Agents coming into the fray, think about the power of the Interaction in lieu of the incident or request. If your Agents are responding and engaging to support or assist an employee or caller, was the service interrupted? Is an incident record necessary? If I put a ‘cost’ to a record, I’d put an Incident more expensive — more potential for engaging resources, analyzing it, auditing it, reviewing it, etc., than an Interaction. If your AI Agents are catching, responding, solving and remediating cases before they’re logged — Interactions have the potential to do more of this catching, further simplifying what elevates up to be considered an incident.</p><p>Granted, some of this might be just as well solved with a Request, but the overhead of REQ/RITM records still feels like a touch of extra overhead — though it may provide the space for the ‘resolving’ agent to reside and work vs. the ‘responding’ AI Agent.</p><blockquote>What are your thoughts, have you seen the ticket table used in creative ways? Did you work at ServiceNow in the early days and care to share a story of its genesis?</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XWMzt0wfY25lqKmVpixXjg.png" /><figcaption>Oh, you spring chicken, ChatGPT…</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A9Jj-p38SwxaQ04j_7KJTg.png" /><figcaption>Not so glamorous : the ‘ticket’</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d5077b5733f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A curmudgeon’s guide to switching to ServiceNow Studio]]></title>
            <link>https://adamhutton.medium.com/a-curmudgeons-guide-to-switching-to-servicenow-studio-de685b0f8933?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/de685b0f8933</guid>
            <category><![CDATA[servicenow-development]]></category>
            <category><![CDATA[servicenow-integration]]></category>
            <category><![CDATA[servicenow]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Sun, 30 Mar 2025 02:53:37 GMT</pubDate>
            <atom:updated>2025-03-30T02:53:37.683Z</atom:updated>
            <content:encoded><![CDATA[<p>This article discusses the differences between ServiceNow’s “Studio” (the legacy application development environment) and “ServiceNow Studio,” its successor. Because of the fun naming of these two products, I’ll refer to them as <em>Old Studio</em> and <em>New Studio</em>. This article’s written in the ServiceNow Yokohama-era.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5R_qtZnfsWwLk7H9S7vZPA.png" /><figcaption>Old Studio (Studio)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LxIUe2XHcEjQKvpptnrBsQ.png" /><figcaption>New Studio (ServiceNow Studio)</figcaption></figure><p>After years of living in Studio day in and day out, it’s grown on me. I appreciate that I have to flip in and out of different browser tabs — some things are just faster to do in UI16. It feels home, i have my cadence down, it’s comfortable. But, since the release of a few new features in Yokohama, I’ve realized that it is time for me to make the switch.</p><h3>Here’s the biggest features that made me a fan</h3><ol><li>Supporting working in <strong>multiple scopes</strong> without ‘switching’ over. For many of my more complex client applications, I’m frequently flipping between scopes. I’m regularly reminding developers and staff which scope a feature should be build in. It’s easy to forget in Studio because your scope itself isn’t front and center — it’s easy to miss in the bottom-corner of the page.</li><li>There’s just more <strong>types of objects available to build</strong> at your fingertips. The Create File menu is packed with features that aren’t represented in Studio at all. Everything else aside, this is a major reason — if you’re still building applications without these features, you’re missing out. Or, you’re spending a lot of extra time flipping over to UI16 or elsewhere.</li><li>The <strong>full app settings menu</strong> is now available. For me this is helpful at the start of every new application. I like to set the default menu and roles — call it habit, but I still prefer to set these right away, lest some other developer on my team lets the Old Studio autocreate new roles and menus that I have to cleanup. Lack of this feature pre-Yokohama still had me starting every new scope in Old Studio — this isn’t necessary anymore with Yokohama.</li><li><strong>Built in Workspace Designer</strong>. I can quickly now create a new workspace from the same environment. This is something that I used to have to bounce over to AES or UI Builder to get a new workspace started.</li><li>I <strong>know my whole scope</strong>. This is a pro and a con (also listed below). When my dev teams are getting ready to publish something, we can quickly see <em>everything </em>that is included in the scope. Even if this list is quite long, an App Repo packages everything — so we should have visiblity into everything.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d-g9cwezpU3ReVjQp-u5yg.png" /><figcaption>Example of the app scope front and center when creating a new file. Also, note the much wider list of available objects you can build.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0GNHRMgQRPneQuZcC5dc7A.png" /><figcaption>The full app menu is now available in Yokohama</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nyFsk7iqUI8bGmAIxp8fCw.png" /><figcaption>Built in Workspace Designer</figcaption></figure><h3>Why I still sometimes go back to Studio</h3><p>It’s faster. For simpler tasks, such as making a table where I already know my desired data model, the old view is just faster. Fewer page loads, quicker data entry, and fewer pretty prompts and graphics to slow things down. To be fair to the ServiceNow team, I could just power-up and use the IDE, if I wanted to be even faster, but I’m not that crazy yet.</p><p>It hides the things I don’t use very often. For example, I don’t typically care about the Number record that gets created when I create a new table. Complex apps can get really bogged down in the leftmost navigation panel with a lot of object classes that I don’t often care about. This might be addressed sometime in the future with increased developer preferences.</p><h3>Closing Thoughts</h3><p>These new features in Yokohama sealed the deal for me. It’s bigger, covers more, gives me more detail on the entirety of the app, lets me work across scopes, and more. I can’t say I won’t still open Old Studio once in a while just for memories and pure browser speed for some tasks, but I can now see that this will be fewer and far between.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/1*OK4ZnR1mdcloaiPw6coEFA.png" /><figcaption>After creating a workspace, the navigation pane becomes l-o-n-g</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de685b0f8933" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ServiceNow Fluent is a big deal]]></title>
            <link>https://adamhutton.medium.com/servicenow-fluent-is-a-big-deal-9c63f35bc5b7?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c63f35bc5b7</guid>
            <category><![CDATA[servicenow-integration]]></category>
            <category><![CDATA[servicenow-development]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[servicenow]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Fri, 28 Feb 2025 21:43:47 GMT</pubDate>
            <atom:updated>2025-02-28T21:43:47.182Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>The ability to represent composite objects in short packages of code will change how we can use GenAI to design solutions on the platform.</blockquote><p>A new feature from ServiceNow, released about six months ago, flew somewhat under the radar. Fluent is part of ServiceNow’s IDE in Xanadu+ and makes ServiceNow configuration records human-readable in simple typescript.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rk8apRS7RBzqUvmC" /><figcaption>Photo by <a href="https://unsplash.com/@mitchel3uo?utm_source=medium&amp;utm_medium=referral">Mitchell Luo</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>For an excellent, short demo of it, watch this ServiceNow Dev Program Channel video from Patrick Wilson and Jay Couture: <a href="https://www.youtube.com/live/PHFZBsbTTtI">https://www.youtube.com/live/PHFZBsbTTtI</a></p><p>Today, the Fluent API is fairly limited but still powerful. You can use it to create ACLs, ATFs, Business Rules, Script Includes, Roles, Records, Tables, and even Scripted REST APIs. I expect this list to grow with future releases to include more complex features.</p><p>Currently, Fluent exists in the realm of pro-code tooling, specifically within the ServiceNow SDK and IDE. Most ServiceNow platform and development teams don’t spend the majority of their time here when configuring platform features.</p><blockquote>Why is this such a big deal?</blockquote><blockquote>Generative AI plus Composite Objects.</blockquote><h3>GenAI and Fluent</h3><p>Here’s where it gets interesting. Since the amount of code needed to generate ServiceNow components is so short, it easily fits into an OpenAI context window — even when using the free version of OpenAI’s ChatGPT GPT-4o model.</p><p>In just a few minutes, I drafted a simple prompt to help me build a new table to store location data related to U.S. counties. I asked it to suggest new attributes that would be relevant. I provided sample code directly from ServiceNow’s Fluent documentation (Yokohama) and asked it to generate the code for me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VoZ1He2Rf_CGKSC5Qd18qA.png" /><figcaption>Initial prompt into ChatGPT</figcaption></figure><p>I had to adjust the prompt a few times, mainly to ensure it used the appropriate prefix for the application (the namespace for my PDI, in this case).</p><p>The first attempt was close but not perfect. Surprisingly, it was quite good — just needed a few minor tweaks, which I could easily adjust through prompt refinement.</p><pre>import { Table, StringColumn, ReferenceColumn, IntegerColumn, DecimalColumn, ChoiceColumn, DateTimeColumn } from &quot;@servicenow/sdk/core&quot;;<br><br>export const x_9076_enh_county = Table({<br>    name: &#39;x_9076_enh_county&#39;,<br>    label: &#39;County&#39;,<br>    schema: {<br>        x_9076_enh_locale_county_name: StringColumn({<br>            label: &#39;County Name&#39;,<br>            maxLength: 255,<br>            unique: true,<br>            mandatory: true<br>        }),<br>        x_9076_enh_locale_county_abbreviation: StringColumn({<br>            label: &#39;County Abbreviation&#39;,<br>            maxLength: 10<br>        }),<br>        x_9076_enh_locale_state: ReferenceColumn({<br>            label: &#39;State&#39;,<br>            mandatory: true,<br>            reference: &#39;x_9076_enh_locale_state_province&#39;<br>        }),<br>        x_9076_enh_locale_fips_code: StringColumn({<br>            label: &#39;FIPS Code&#39;,<br>            maxLength: 5,<br>            unique: true<br>        }),<br>        x_9076_enh_locale_population: IntegerColumn({<br>            label: &#39;Population&#39;,<br>            mandatory: false<br>        }),<br>        x_9076_enh_locale_land_area: DecimalColumn({<br>            label: &#39;Land Area (sq mi)&#39;,<br>            mandatory: false,<br>            scale: 2<br>        }),<br>        x_9076_enh_locale_timezone: ChoiceColumn({<br>            label: &#39;Timezone&#39;,<br>            choices: {<br>                eastern: { label: &#39;Eastern&#39; },<br>                central: { label: &#39;Central&#39; },<br>                mountain: { label: &#39;Mountain&#39; },<br>                pacific: { label: &#39;Pacific&#39; },<br>                alaska: { label: &#39;Alaska&#39; },<br>                hawaii: { label: &#39;Hawaii&#39; }<br>            }<br>        }),<br>        created_on: DateTimeColumn({<br>            label: &#39;Created On&#39;,<br>            auto_value: &#39;created&#39;,<br>            read_only: true<br>        }),<br>        updated_on: DateTimeColumn({<br>            label: &#39;Updated On&#39;,<br>            auto_value: &#39;updated&#39;,<br>            read_only: true<br>        })<br>    },<br>    display: &#39;x_9076_enh_locale_county_name&#39;,<br>    actions: [&#39;create&#39;, &#39;read&#39;, &#39;update&#39;, &#39;delete&#39;],<br>    allow_client_scripts: true,<br>    allow_new_fields: true,<br>    allow_ui_actions: true,<br>    allow_web_service_access: true,<br>    extensible: true,<br>    audit: true,<br>    text_index: true,<br>    attributes: {<br>        update_sync: true<br>    },<br>    index: [<br>        {<br>            name: &#39;idx_county_name&#39;,<br>            element: &#39;x_9076_enh_locale_county_name&#39;,<br>            unique: true<br>        },<br>        {<br>            name: &#39;idx_fips_code&#39;,<br>            element: &#39;x_9076_enh_locale_fips_code&#39;,<br>            unique: true<br>        }<br>    ]<br>});</pre><p>A simple second prompt, including the error message and a quick copy-paste from the ServiceNow documentation, resolved the issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rx_U-Co0a5Ek6JXl5s-TGA.png" /><figcaption>Second prompt to fix a few bugs in the code</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sGcq---pM-M6UG42dsEqeA.png" /><figcaption>Revised code from the second prompt</figcaption></figure><p>Here’s what the revised version outputted:</p><pre>import { Table, StringColumn, ReferenceColumn, IntegerColumn, DecimalColumn, ChoiceColumn, DateTimeColumn } from &quot;@servicenow/sdk/core&quot;;<br><br>export const x_9076_enh_county = Table({<br>    name: &#39;x_9076_enh_county&#39;,<br>    label: &#39;County&#39;,<br>    schema: {<br>        x_9076_enh_locale_county_name: StringColumn({<br>            label: &#39;County Name&#39;,<br>            maxLength: 255,<br>            unique: true,<br>            mandatory: true<br>        }),<br>        x_9076_enh_locale_county_abbreviation: StringColumn({<br>            label: &#39;County Abbreviation&#39;,<br>            maxLength: 10<br>        }),<br>        x_9076_enh_locale_state: ReferenceColumn({<br>            label: &#39;State&#39;,<br>            mandatory: true,<br>            reference: &#39;x_9076_enh_locale_state_province&#39;<br>        }),<br>        x_9076_enh_locale_fips_code: StringColumn({<br>            label: &#39;FIPS Code&#39;,<br>            maxLength: 5,<br>            unique: true<br>        }),<br>        x_9076_enh_locale_population: IntegerColumn({<br>            label: &#39;Population&#39;<br>        }),<br>        x_9076_enh_locale_land_area: DecimalColumn({<br>            label: &#39;Land Area (sq mi)&#39;,<br>            scale: 2<br>        }),<br>        x_9076_enh_locale_timezone: ChoiceColumn({<br>            label: &#39;Timezone&#39;,<br>            choices: {<br>                eastern: { label: &#39;Eastern&#39; },<br>                central: { label: &#39;Central&#39; },<br>                mountain: { label: &#39;Mountain&#39; },<br>                pacific: { label: &#39;Pacific&#39; },<br>                alaska: { label: &#39;Alaska&#39; },<br>                hawaii: { label: &#39;Hawaii&#39; }<br>            }<br>        }),<br>        x_9076_enh_locale_created_on: DateTimeColumn({<br>            label: &#39;Created On&#39;,<br>            auto_value: &#39;created&#39;,<br>            read_only: true<br>        }),<br>        x_9076_enh_locale_updated_on: DateTimeColumn({<br>            label: &#39;Updated On&#39;,<br>            auto_value: &#39;updated&#39;,<br>            read_only: true<br>        })<br>    },<br>    display: &#39;x_9076_enh_locale_county_name&#39;,<br>    actions: [&#39;create&#39;, &#39;read&#39;, &#39;update&#39;, &#39;delete&#39;],<br>    allow_client_scripts: true,<br>    allow_new_fields: true,<br>    allow_ui_actions: true,<br>    allow_web_service_access: true,<br>    extensible: true,<br>    audit: true,<br>    text_index: true,<br>    attributes: {<br>        update_sync: true<br>    },<br>    index: [<br>        {<br>            name: &#39;idx_county_name&#39;,<br>            element: &#39;x_9076_enh_locale_county_name&#39;,<br>            unique: true<br>        },<br>        {<br>            name: &#39;idx_fips_code&#39;,<br>            element: &#39;x_9076_enh_locale_fips_code&#39;,<br>            unique: true<br>        }<br>    ]<br>});</pre><p>GPT still is far from perfect, but this is my own error. In these rows:</p><pre>export const x_9076_enh_county = Table({<br>    name: &#39;x_9076_enh_county&#39;,<br>    label: &#39;County&#39;,<br>    schema: {</pre><p>I realized my original prompt incorrectly instructed it to name the table. That was an easy fix, and I didn’t even need to go back to GPT for it.</p><p>Here’s the ServiceNow IDE building the table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_jDBlTNjjtDID-GmwdDAmw.png" /></figure><p>And the resulting table in the old school Studio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PUcAxE3BL67ZDh4ODJq_HQ.png" /></figure><p>Yes, there’s some things wrong with this table! Very odd to create custom fields for created and updated on — but hey, it is this LLMs first try making a ServiceNow table.</p><p>This is a very rough and fast demo of using GenAI to both help me design the table and write the code to build the table. I hacked this together in an hour — so I appreciate that all could be greatly improved using better prompts and trying out different models. Think of what better tuned LLMs from Now Assist for Creators could provide!</p><h3>Composite Objects</h3><p>Composite Objects — think Flows and Playbooks — comprise comparatively huge payloads of XML and JSON, sometimes with one nested in the other.</p><p>First, let’s compare the typescript Fluent code to make a new table to the payload found in an old school customer update.</p><p>Here’s the Fluent code in typescript:</p><pre>import { Table, StringColumn, ReferenceColumn, IntegerColumn, DecimalColumn, ChoiceColumn, DateTimeColumn } from &quot;@servicenow/sdk/core&quot;;<br><br>export const x_9076_enh_county = Table({<br>    name: &#39;x_9076_enh_county&#39;,<br>    label: &#39;County&#39;,<br>    schema: {<br>        x_9076_enh_locale_county_name: StringColumn({<br>            label: &#39;County Name&#39;,<br>            maxLength: 255,<br>            unique: true,<br>            mandatory: true<br>        }),<br>        x_9076_enh_locale_county_abbreviation: StringColumn({<br>            label: &#39;County Abbreviation&#39;,<br>            maxLength: 10<br>        }),<br>        x_9076_enh_locale_state: ReferenceColumn({<br>            label: &#39;State&#39;,<br>            mandatory: true,<br>            reference: &#39;x_9076_enh_locale_state_province&#39;<br>        }),<br>        x_9076_enh_locale_fips_code: StringColumn({<br>            label: &#39;FIPS Code&#39;,<br>            maxLength: 5,<br>            unique: true<br>        }),<br>        x_9076_enh_locale_population: IntegerColumn({<br>            label: &#39;Population&#39;<br>        }),<br>        x_9076_enh_locale_land_area: DecimalColumn({<br>            label: &#39;Land Area (sq mi)&#39;,<br>            scale: 2<br>        }),<br>        x_9076_enh_locale_timezone: ChoiceColumn({<br>            label: &#39;Timezone&#39;,<br>            choices: {<br>                eastern: { label: &#39;Eastern&#39; },<br>                central: { label: &#39;Central&#39; },<br>                mountain: { label: &#39;Mountain&#39; },<br>                pacific: { label: &#39;Pacific&#39; },<br>                alaska: { label: &#39;Alaska&#39; },<br>                hawaii: { label: &#39;Hawaii&#39; }<br>            }<br>        }),<br>        x_9076_enh_locale_created_on: DateTimeColumn({<br>            label: &#39;Created On&#39;,<br>            auto_value: &#39;created&#39;,<br>            read_only: true<br>        }),<br>        x_9076_enh_locale_updated_on: DateTimeColumn({<br>            label: &#39;Updated On&#39;,<br>            auto_value: &#39;updated&#39;,<br>            read_only: true<br>        })<br>    },<br>    display: &#39;x_9076_enh_locale_county_name&#39;,<br>    actions: [&#39;create&#39;, &#39;read&#39;, &#39;update&#39;, &#39;delete&#39;],<br>    allow_client_scripts: true,<br>    allow_new_fields: true,<br>    allow_ui_actions: true,<br>    allow_web_service_access: true,<br>    extensible: true,<br>    audit: true,<br>    text_index: true,<br>    attributes: {<br>        update_sync: true<br>    },<br>    index: [<br>        {<br>            name: &#39;idx_county_name&#39;,<br>            element: &#39;x_9076_enh_locale_county_name&#39;,<br>            unique: true<br>        },<br>        {<br>            name: &#39;idx_fips_code&#39;,<br>            element: &#39;x_9076_enh_locale_fips_code&#39;,<br>            unique: true<br>        }<br>    ]<br>});</pre><p>Here’s the customer update xml payload for just creating the table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1TdtPZjj-Tth9jq2ptRruw.png" /><figcaption>Customer update version of creating a table</figcaption></figure><p>This isn’t a <em>huge</em> difference. The customer update record related to creating a table is fairly clear. It is compressed and not as easy to read as the typescript.</p><p>This is only part of the story though. We can’t grab just the customer update for the table, we have to grab all the other objects, too:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nZb6MkYAkoZlQ6B4aCw3Dw.png" /></figure><p>I won’t paste all this in here, but here’s a quick screenshot. It is about 250 lines, but much less human-readable and <em>much more </em>ServiceNow-specific.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J0m5DWJn9ll1b-ZkTXvdlA.png" /><figcaption>The customer update package of records representing the table.</figcaption></figure><p>This is just for a table creation with a few fields. Not all created objects are as friendly.</p><h4>What a Flow looks like in XML, today</h4><p>Let’s take the example of a simple Flow. Not too many steps, but the resulting customer update record is massive! This small, very simple flow, is almost 1000 lines of code that are largely tough to read.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5IdmFbEJpif7jBbWF3Dl7Q.png" /><figcaption>A very simple flow</figcaption></figure><p>Here’s the Customer Update record.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NF0EHn0VadxMIEEoQTdzng.png" /><figcaption>A massive customer update record!</figcaption></figure><h3>Where GenAI comes in</h3><p>This is where it should be very clear: trying to have GenAI generate traditional XML update sets would be extremely challenging, if not impossible. A LLM would need to know a LOT about the ServiceNow payload structure. When Fluent is able to be used to describe more complex, advanced objects, the payload now becomes much more manageable (in terms of token size) and generic.</p><blockquote>Where I’m going with all these code comparisons — the Fluent typescript is very easy to read, much shorter, and less ServiceNow-specific. That means we can have much better luck with cheap LLMs to be able to create reasonably useful elements.</blockquote><p>As the capabilities of Fluent expand — into different object types and into being able to <em>edit</em> configurations, it will be exciting to see new ways to be able to work with ServiceNow code from various LLMs.</p><p>The impacts of this could be wild, from being able to create new catalog items on-demand by a helpful copilot agent to much richer capabilities from Now Assist for Creators.</p><h3>References</h3><p>Table API — ServiceNow Fluent (Yokohama Documentation): <a href="https://www.servicenow.com/docs/bundle/yokohama-application-development/page/build/servicenow-sdk/reference/table-api-now-ts.html">https://www.servicenow.com/docs/bundle/yokohama-application-development/page/build/servicenow-sdk/reference/table-api-now-ts.html</a></p><p>ServiceNow IDE and Fluent (sdk v2) w/Patrick Wilson and Jay Couture — Creator Toolbox: <a href="https://www.youtube.com/watch?v=PHFZBsbTTtI">https://www.youtube.com/watch?v=PHFZBsbTTtI</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c63f35bc5b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ITSM, Asset Management and the CMDB: Know who your customers are]]></title>
            <link>https://adamhutton.medium.com/itsm-asset-management-and-the-cmdb-know-who-your-customers-are-0a573b8f4a3c?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a573b8f4a3c</guid>
            <category><![CDATA[servicenow]]></category>
            <category><![CDATA[it-infrastructure]]></category>
            <category><![CDATA[cmdb]]></category>
            <category><![CDATA[servicenow-cmdb]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Thu, 27 Feb 2025 01:40:34 GMT</pubDate>
            <atom:updated>2025-02-27T01:40:34.682Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Many IT organizations have CMDB and Asset Management functions that are focused on inventorying accumulation and can miss a focus on value delivery. This post tries to lay out a few strategies for how to build an asset and CMDB roadmap where the data that’s collected follows alongside specific value through usage for that data.</blockquote><h3>Has your CMDB become a quest for data collection, simply for goal of building a complete repository of assets? If this is your goal, are you still building a CMDB?</h3><p>Many organizations I’ve worked with over the years have been on a mythical question to ‘finish’ their CMDB. A pursuit of years of investment and time in building completeness in coverage of <em>all</em> of their enterprise assets. And, given the nature of technology constantly changing, deploying new infrastructure, retiring the old — it never is finished.</p><blockquote>Every data point captured in ITAM and the CMDB has a cost to it. A cost to acquire it and maintain it. This article argues to directly tie your data acquisition and upkeep to the needs and use cases from the processes that use it.</blockquote><p>There are some scenarios where 100% asset coverage is the goal. These are typically driven through regulatory interpretation. If <em>coverage</em> is the end goal, then I’d argue you’re building an asset repository, not serving the ITSM-centric (think ITIL v3, where the key word is management of rather than acquisition of). This is a subject for another day, here I’m focusing only on how to plan a roadmap of where and how to plan your development and related projects in ITAM and CMDB.</p><p>Note that for brevity in this article, I sometimes may refer to the data stores of ITAM and the CMDB as A/CMDB. I appreciate that these are two different process areas — Asset Management and Configuration Management. For the ServiceNow-minded, I also am aware that these two data sets have different tables and class structures and, frequently, different content and sources feeding them. My focus here is generally on the data acquisition and normalization into the A/CMDB, not with the processes themselves.</p><p>Also, since my daily focus is on the ServiceNow platform, this article does presuppose some basic knowledge about these capabilities specific to that platform. I’ll casually toss around terms like Service Graph Connectors</p><h3>Starting your roadmap</h3><p>Frequently, I see organizations build the roadmaps for their A/CMDB based on technology deployed, the Service Graph Connectors that they own, and availability of data.</p><p>I often have to step back with these organizations and ask ‘to what value?’ What are they trying to accomplish?</p><p>Usually these start with the basics from the most common ITSM processes:</p><ul><li>Faster time to analyze a failed service or reported incident</li><li>Better correlation of data to support root cause analysis in problem management</li><li>More efficient change scheduling and risk analysis when planning changes</li></ul><p>Note, the above are all <em>process</em>-centric and focused on ITSM-related objectives. I’m assuming here that there is a direct linkage between the customers of the CMDB and the team that manages and curates the CMDB. The customers should provide the requirements, right? This isn’t always the case. Later on, I’ll get into an example of CMDB-objectives for the CMDB.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GOtqn4zxGJi0ZqEr" /><figcaption>Photo by <a href="https://unsplash.com/@jankolar?utm_source=medium&amp;utm_medium=referral">Jan Antonin Kolar</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Who does your A/CMDB serve?</h4><p>This should be an easy question, but it helps to lay this out clearly. The easy one is that it serves your ITSM processes — typically incident, problem and change management. It, hopefully, serves your service desk function.</p><p>But expanding beyond that, is your customer also: Audit and GRC functions; Cyber security; Configuration compliance; Customer service; and others?</p><p>If you consider them as customers, do you hold customer feedback sessions as part of building your product roadmap? Do you know their objectives (automation, efficiency gains, or other process-specific outcomes) in the next year?</p><h4>Ranking and stacking</h4><p>How do you prioritize or rank the initiatives that add the most value?</p><p>This helps to think in a matrix: what adds direct value, what is the associated effort, then — can it be reused or have network effects across processes. Lastly, would the effort align to A/CMDB automations for its own sake, improving automations, reducing manual management, or improving overall data quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mTCWJW1Ffl5TnsRSFKwKCg.png" /></figure><h4>Removing the unused</h4><p>Back to my statement earlier that every data point in your A/CMDB has a cost to acquire and maintain. I’m not referring here to database storage fees, instead it is the human labor cost to build or automate the curation of that data. Nothing’s free — accumulation of data is a form of tech debt.</p><blockquote>When have you considered removing a source or class of A/CMDB data that was of no value to your ServiceNow process users?</blockquote><h3>A practical walkthrough of right-sized CMDB objectives</h3><p>These types of process goals great for aspirations, but not for any practical usefulness. What’s more effective is to plan objectives a few degrees lower. By doing this, you move away from the lofty to the specific. Let’s try it:</p><ul><li>In 2025, we must 50% be faster at responding to our customers reporting outages of our core processing systems and reduce time to resolve by 25%.</li><li>Surface the specific, on premises deployed servers, network, and storage infrastructure that directly runs our customer-facing applications on-demand when an Incident Response Engineer or Major Incident Responding engineer.</li><li>Solving for our primary customer-reported outages in 2023–2024</li></ul><p>The above statement is broad, but it adds a few key limitations in scope:</p><ol><li>Classes of devices: servers, network and storage</li><li>Deployment model: on premises-deployed</li><li>Category of application: customer facing AND customer-reported in 2023–2024</li><li>User of the solution: Incident Response / Major Incident Response Engineer</li><li>User Interface: surfacing the information to these engineers, note it isn’t requiring live data inside ServiceNow (at least not for this particular requirement)</li><li>Relationship data: this is critical as your customer-reported outages will need to be related down to the unavailable services; plan to do some root cause analysis</li></ol><p>Now, each one of these can be taken and broken into an action plan.</p><ul><li>Analyze your customer-reported outage data to build your top ten scenarios to dig into. How long did it take to respond to these, on average, stratified by system and type of outage.</li><li>Map where the time is spent. The above statement indicates 50% faster time to respond. Where was the time spent? Improving your CMDB used only by engineers isn’t any help if 90% of the overall time elapses from a customer care agent before it is recognized as an outage!</li></ul><p>Now, assuming the time spent is actually by the engineers restoring the services…</p><ul><li>Understand the infrastructure they operate on, this is a chance to validate and update your requirements — do they run on prem? What <em>specific</em> information would have helped those agents respond more quickly? This may require some after-action reviews, hopefully this was done relatively recently after the incident.</li><li>Now, based on what you learned from those after action reports — how should you look back at exactly what you need to enrich in the information available to your engineers.</li></ul><p>Notice here, I’m still not being specific to how you’re going to implement these improvements to your CMDB. I’m still organizing around what you should be improving as information available to your agents. Some of this information may need to be added to your CMDB in the form of new attribute collection, relationship enrichment, or even new data sources altogether.</p><p>For a ServiceNow-centric blog, I’m not being very ServiceNow-centric! Because, up to this point, this isn’t a technology issue. Everything above is focused core business analysis activities. Ask why. Keep asking it.</p><blockquote>The biggest challenges I see with clients building their CMDB isn’t the technology, it’s prioritizing those technology efforts towards specific operational objectives.</blockquote><p>Now that we have a much more precise measurement for improvement and the factors involved. Which of these specifically relate to the CMDB?</p><ul><li>Some may be handled via faster customer case handling and handoffs between customer care and engineering teams.</li><li>Some may be found in improvements by application monitoring, such as designing-in synthetic monitoring solutions simulating customer transactions. Catching these long before customers have to phone in to complain can give engineers a huge timesaver.</li><li>Some may be found in automations skipping right past traditional, human-based incident response. If synthetic monitoring detects the outage, why not build in automated analysis tools, failovers, capacity adjustments and restarts?</li><li>Even better, why not build in anomaly detection and catch outages before they arise?</li></ul><p>This is a perfect example where multiple disciplines in IT work together to jointly improve a set of services.</p><p>What we are left with are the specific improvement opportunities related to the CMDB. Most likely, this is building the last mile of relationship information from what and how customers call to report an issue and the underlying technologies that deliver it.</p><h3>CMDB Objectives for the CMDB</h3><p>Not all CMDB teams have a direct line of sight to the objectives of the processes they serve. Think of this stream of work as IT for IT or, in software development, tech debt or refactoring sprints.</p><p>These can be opportunities to:</p><ul><li>Automate manual tasks, such as data certification — but also, can you automate some of those data certification tasks, rather than just shifting the work?</li><li>Expand the use of data quality metrics in your health dashboard, automate monitoring of data quality</li><li>Automate the monitoring of your MID Servers and discovery jobs</li><li>Work with your Windows administration teams to automate credentials, increase security of stored credentials, or increase the reliability of those credentials</li><li>Define and monitor archiving rules and other logic for getting stale data out</li></ul><p>Note, these aren’t in the expansion of data — that comes above. These are all centered around making it easier and more reliable to curate the data you already have.</p><h3>Wrapping up</h3><p>Enterprise asset management and CMDB initiatives is a function, not a project. It’s an ongoing role that continually is chasing an ideal state. Hopefully some of these perspectives can be useful in how to run the race for the long-term and design-in continual improvement by often demanding and conflicting customer owner needs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a573b8f4a3c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reflections on ServiceNow architecture, 2024 through 2025]]></title>
            <link>https://adamhutton.medium.com/reflections-on-servicenow-architecture-2024-through-2025-f239209b872f?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/f239209b872f</guid>
            <category><![CDATA[servicenow]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Sun, 23 Feb 2025 15:54:12 GMT</pubDate>
            <atom:updated>2025-02-23T15:54:12.177Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>This article is written in February 2025, following along with the launch of the Yokohama release. With the rapid evolution of ServiceNow, many of the features discussed here are in flux, making it an exciting time for platform developers.</blockquote><p>Back in 2023, I wrote a few articles suggesting that organizations revisit how they think about development on the ServiceNow platform. The key theme then was leveraging application scopes to encapsulate similar features, allow for more advanced code management and deployment practices, and to reduce the inherent risk of so many developers having ‘global’ reach when developing new features.</p><p>The platform has advanced significantly since then and so have many development and platform teams. While the vision that I described back then hasn’t fully taken hold, many organizations with advanced platform teams have started to embrace it. Beyond these innovators, many platform teams struggle to make the jump — or some have and have faced a rough and tumble journey.</p><p>Indeed, in the past few years, the platform has made huge strides in the technical features available to pro-code developers — with new capabilities on the horizon. The adoption of these features seems limited to niche applications. And, that may be a good thing.</p><p>Keep an eye on new changes, the consolidation of the IDE and ServiceNow Studio, Workflow Studio, and maturity of the SDK — but the wild opportunities that these combined with Fluent promise when applied to Generative AI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sRjX9zQWYlNenLPn" /><figcaption>Photo by <a href="https://unsplash.com/@christofw?utm_source=medium&amp;utm_medium=referral">Christof</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Rocky roads and pragmatism</h3><p>I had a ‘go forth’ attitude toward application scoping and code management back in ’23. In hindsight, I had rose colored glasses clouding my perspective — especially in some of the difficulties associated with code deployments. Working with many different organizations over the past couple of years, I’ve evangelized application scoping practices with limited success, and sometimes increasing the complexity of my own projects. While I still think it is the best way to manage development on ServiceNow, I have since had my own dose of pragmatism.</p><p>This is a look back at what I still agree with, what I don’t, and why — for even what I still agree with — I have slightly different reasons for it.</p><h3>What I still agree with</h3><blockquote>Get out of the global scope</blockquote><p>Development in global scope should be by-exception only. This I still agree with more than ever. As ServiceNow is deployed in enterprises in more and more complex ways, it is more critical to encapsulate your designs and features. Back in ’23, I reasoned the driver of this as more of a code and configuration management; today, I see it driven from a security and management perspective. The expansion of the platform into use cases such as Financial Services Operations and Operational Technology Management introduce a major driver for scope encapsulation — <strong>isolation</strong>.</p><blockquote>Contrary to our experiences since the beginning of the ServiceNow platform: the features you build and the code you write — maybe <em>shouldn’t </em>be always, freely open to every other developer on the platform, by default.</blockquote><blockquote>Watch for the evolution of features like ServiceNow Vault and Code Signing.</blockquote><p>ServiceNow’s had these features for many years, such as cross scope access privileges and application administration, but 99% of the time (an anecdotal number), we make everything open to everyone. All developers often have full access to see, use, call, and — sometimes — edit, the code in anyone else’s scope. In the next few years, as applications increase in business criticality and apply toward direct value stream-related operations (i.e., business apps), the need to isolate what some developers are building and are able to utilize will become much more visible.</p><blockquote>Ease of deployment</blockquote><p>I still don’t want to do production deployments any other way! This still holds true. For custom applications or features, nothing is better than the ‘all in’ and general reliability of simply upgrading an installed application. I know it’s all there, I have great logs to check any skip history, I can repair on the rare occasion I’d need to. My deployment runbooks can be easy as cake compared to the precise sequencing of multiple update sets.</p><p>When I am forced to go back to update sets, god-forbid <em>non-batched</em> ones, I feel like I’m going back in time on the platform. BUT, there are many, many still-legitimate reasons to use pointed update sets to commit a change to a forward environment.</p><h3>What I would change</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wbTFq_kcC5DOf7b4" /><figcaption>Photo by <a href="https://unsplash.com/@lyovon?utm_source=medium&amp;utm_medium=referral">Levon Vardanyan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><blockquote>Deploying via App Repo</blockquote><p>My “<a href="https://adamhutton.medium.com/now-flow-feature-development-for-servicenow-pro-code-apps-d6c1a82d8b58">Now Flow</a>” article was very aspirational thinking. The complexity and work associated with code management and thinking that you can (easily) do it in something like GitHub. For the most part, today, ServiceNow’s integration with Git operates more like a code backup than code <em>management, </em>especially for composite objects, like Flows or Playbooks.</p><blockquote>Watch for ServiceNow Fluent to help alleviate the challenges with composite objects.</blockquote><p>The biggest challenge I underestimated was the effort required for App Repo deployments. Far too many deployments are incremental and many of these <em>have to be</em> incremental. Large application scopes where many developers are building features have serious limitations in being able to deploy the whole package that goes along with an App Repo publication.</p><p>To move to full package deployments, the presence of a sub-development or feature development environment often isn’t available. Many teams move code to forward environments for in or near-sprint functional testing, something that to keep in practice would require another feature-level testing environment — again, not generally available to most organizations.</p><blockquote>Watch for ServiceNow Sandboxes to help with the challenge of feature or branch-level development environments.</blockquote><p>Alongside these limitations, I underestimated a few other complexities that limit the day-to-day adoption of source control practices in ServiceNow. These are found not only in the number of instances required, but in things like the know-how and practices for rebasing code in git, some brittleness found in very large application scopes (though these are mostly alleviated in delta loading), one-scope-per-repo maintenance overhead, and git training and management overhead that simply isn’t the norm with most ServiceNow teams.</p><blockquote>Leading practice is to keep scopes relatively small and manageable. This helps with planning releases. But, in doing this, you end up with lots of scopes. This results in lots of repositories to manage!</blockquote><p>A seemingly minor but significant limitation is the one-scope-per-repository limitation. This is particularly annoying with GitHub. Azure DevOps has an advantage here, as it allows one project to include many repos under its purview. Using GitHub across many scopes adds additional overhead and administration complexity if you have one application or packaged releases that cover many application scopes — this is common if you’re building up an out of box application.</p><p>Lastly, other factors, such as investment in ATF coverage and constant curation, that is needed for safely deploying full-scope App Repo package releases simply aren’t worth the investment compared to new feature development. Again, this is something that will change as much higher risk-profile applications make their way to the platform. This will take some time and, unfortunately, experience in downtime when something goes wrong.</p><blockquote>Watch for Now Assist for Creators to enable faster, easier development and curation of quality ATF coverage.</blockquote><h3>Bright outlooks</h3><p>You may have noticed throughout this article, I’ve called out a number of new platform capabilities: Fluent, Sandboxes, Code Signing. The pro-code landscape of features available from ServiceNow is rapidly progressing. It’s been a while since my last post here, but with the rapid convergence of these new capaibilities — keep an eye out. I’ll try to post new updates as I learn about these more and how they apply in-practice.</p><h3>References</h3><ul><li>Yokohama Documentation: <a href="https://www.servicenow.com/docs/bundle/yokohama-application-development/page/build/custom-application/reference/building-pro-code-applications.html">Building pro-code applications</a></li><li>YouTube — <a href="https://www.youtube.com/watch?app=desktop&amp;v=PHFZBsbTTtI">ServiceNow Dev Program: ServiceNow IDE and Fluent (sdk v2) w/Patrick Wilson and Jay Couture — Creator Toolbox</a></li><li>As always, make sure to follow ServiceNow’s <a href="https://www.servicenow.com/community/developer-advocate-blog/bg-p/developer-advocate-blog">Developer Advocate</a> space:</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f239209b872f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A dive into global-scoped application packaging]]></title>
            <link>https://adamhutton.medium.com/a-dive-into-global-scoped-application-packaging-6ee42135ce75?source=rss-b4ba316c8325------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ee42135ce75</guid>
            <category><![CDATA[servicenow]]></category>
            <category><![CDATA[servicenow-development]]></category>
            <category><![CDATA[servicenow-architecture]]></category>
            <dc:creator><![CDATA[Adam Hutton]]></dc:creator>
            <pubDate>Thu, 06 Apr 2023 01:28:22 GMT</pubDate>
            <atom:updated>2023-04-06T01:28:47.816Z</atom:updated>
            <content:encoded><![CDATA[<p><em>ServiceNow global-scope apps (or “global app bundles”) and how they can help you organize your development.</em></p><p>You don’t need to use update sets to manage and migrate development in ServiceNow’s “Global” scope. You can take advantage of all of the built-in capabilities of Studio, Git integration, and App Repo deployment models even for ServiceNow configurations performed in the global scope using global scope applications packages.</p><p>Development in the global scope should generally be ‘by exception only.’ It’s where you build things when you <em>have</em> to. When you either need to interact with global objects and when you need everything else on the platform to have access to what you build. With that said, there are still many cases today you have to work in Global because that’s the only place the objects you need to develop work, or where (most commonly) they already are.</p><p>There’s an often-overlooked feature, released sometime around Paris, that allows you to allocate those global configurations into a package, similar in nature to an application scope. You can look in your instance for the plugin “Global Application File Management” (com.snc.global_app_files). It is automatically installed in new instances. The features available with Global Applications have been quietly increased and improved.</p><p>It’s not quite the same as a proper application scope, but it does the job. It lets you organize your work in Studio and take advantage of all of the code and deployment management features that come along with it.</p><h3>Benefits of Global-Scope Application Packages</h3><p>Global Application Packages provide several benefits to ServiceNow developers and platform administrators:</p><ul><li>Simplifies maintenance by capturing related developed objects together in a common container (<em>sort of </em>an application scope)</li><li>Ability to use the Application Repository to version and publish changes to the package</li><li>Provides developers with the ability to use Studio to manage configurations under a common IDE</li><li>Allows connection to Git for code management</li><li>Compared to properly scoped applications, you don’t have to deal with cross-scope access</li></ul><h3>Limitations on Global-Scope Application Packages</h3><p>As far as I can tell, there are no significant negatives or cons associated with application packages compared to traditional update sets; however, there are scenarios where they may not be value adding. These would include:</p><ul><li>Features are configured differently per-environment, such as system properties, SSO configurations, data sources</li><li>Out of box components that haven’t been modified (why would you want to move these?)</li></ul><p>Limitations compared to application scopes are essentially the same as any global configuration compared to a scoped object.</p><ul><li>Scoping offers better performance protection</li><li>Scoped access control and management, including restricted caller access and cross-scope privilege restrictions</li><li>Delegated developer and administration functionality</li></ul><p>A characteristic of Global-Scope Application Packages is that because objects are entered into a registry, global objects can only be ‘claimed’ by one global package. However, you can change the claim and move it around to a different package, if you need to.</p><h3>Conclusions</h3><p>Development in the global scope is a necessary evil. When you need to develop there, it is nice to have the ability to organize and manage what you’re building with the same type of control and features as scoped applications. For many organizations, with years of developed objects in the global scope, Scoped Application Packages represent a way to start gaining control and managibility of these features by moving their existing objects into it.</p><p>Global Application Packages don’t replace or augment the need for or the advantages of real application scopes, but they do provide an additional feature into a developer and platform administrator’s toolkit. If used with careful planning and organization, they a way to further gain control of complex deployments.</p><h3>References</h3><ul><li>Application Plugin: “Global Application File Management” (id: com.snc.global_app_files)</li><li><a href="https://developer.servicenow.com/blog.do?p=/post/paris-source-control/">Global App Source Control — New in Paris (servicenow.com)</a></li><li>Check out the “Application File Claims” table in your instance and UI Actions “Migrate to Global Application,” shown below</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K61ft3CdRu1bx_KfWY92RQ.png" /><figcaption>Global Application File Management Plugin (com.snc.global_app_files)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S3ys7h3LqfSYERSGmiKnZQ.png" /><figcaption>Application File Claims Table</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bbA5_OChUdOaOdLMGqad7A.png" /><figcaption>An example Application File Claim record</figcaption></figure><figure><img alt="A screenshot of ServiceNow’s UI Action, List Choice, that allows pushing an update set’s contents into a ‘global-scope’ application package." src="https://cdn-images-1.medium.com/max/1024/1*GBRvA51IkUQBEKjTXTL5-w.png" /><figcaption>UI Action on sys_update_set</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qObTG8h6Ex8-0Eibxra8Ug.png" /><figcaption>UI Action on sys_update_xml</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lDIrnw2E-VZju0zvPVwK8g.png" /><figcaption>Example script include moved into a Global Application Package (previously in the Default update set)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YqueM6bUlC7Crcm1YCX4Fg.png" /><figcaption>Example use of the Migrate to Global Application UI Action</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ee42135ce75" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>