<?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[Sola Security - Medium]]></title>
        <description><![CDATA[Security thinking for builders who ship. Practical takes on cloud security, AI, and product led defense. - Medium]]></description>
        <link>https://medium.com/sola-security?source=rss----3b49f145bb43---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Sola Security - Medium</title>
            <link>https://medium.com/sola-security?source=rss----3b49f145bb43---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 03:02:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/sola-security" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Context is the Architecture: Rethinking Security Platforms in the LLM Era]]></title>
            <link>https://medium.com/sola-security/context-is-the-architecture-rethinking-security-platforms-in-the-llm-era-a70e36636787?source=rss----3b49f145bb43---4</link>
            <guid isPermaLink="false">https://medium.com/p/a70e36636787</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm-applications]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[context-engineering]]></category>
            <dc:creator><![CDATA[Leon Goldberg]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 06:00:36 GMT</pubDate>
            <atom:updated>2026-07-06T06:55:06.459Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WfJQxnYq7SgkERrDmXF2Zg.png" /></figure><p>A scanner flags an over-broad IAM role. The finding is accurate: the role can do far more than it should. But what it states and what you need to know are two different things. The finding tells you what is true of the role. Whether it matters here lives somewhere else. In the identity provider, the role traces back to Dana, a contractor who left months ago. In the data catalog, that role can read a bucket of customer records. The bucket turns out to be reachable. Three consoles later, an analyst has a conclusion no single tool held: a dormant contractor still has a live path to customer data. That conclusion had been sitting in a queue beside a hundred benign “role too broad” alerts that looked exactly the same.</p><p>That manual reassembly is the triage loop: pivoting across tools to decide whether a finding is a real problem or noise. Across the alert queue, it is where much of an analyst’s time goes. Closing it is the most valuable thing a security platform can do. Another detector won’t close it; it only adds a hundred-and-first alert to the same queue. The loop closes when the system does the reassembly itself, relating the role to the contractor to the bucket to the network and handing back the conclusion with its evidence. That is an architectural problem.</p><p>In this article, we’ll walk through an architecture that closes the loop in the LLM era, based on what we’ve spent the last two years building. <br>We start with the one bet made before any code: <strong>whether to surface a catalog of known problems, or connect the dots across the whole discipline</strong>. Then the three problems that bet creates.</p><ol><li><strong>Breadth</strong>: acquiring an entire estate and modeling everything across its many layers.</li><li><strong>Depth:</strong> turning that raw data into accurate intelligence, cheaply and consistently enough to keep current.</li><li><strong>Performance:</strong> reasoning over hundreds of billions of relationships the moment a question lands.</li></ol><p>And finally, what it takes to trust the result: a graph that stays coherent as its sources change and enforces who can see which edge.</p><blockquote>The finding is accurate…but it only tells you what is true of the role. Whether it matters lives somewhere else.</blockquote><h4>Context, not the model</h4><p>Andrej Karpathy popularized “context engineering” in mid-2025, and Anthropic frames it as the discipline beyond prompt engineering: curating the right tokens to put in front of a model at inference time [1]. The New Stack put it plainly: the real bottleneck in enterprise AI is not the model, it is context [2]. Even vendors bolting AI onto established security stacks describe the capability the same way [3]. We benchmarked it ourselves [8,9], and will return to it later in the article. Before LLMs, nothing could reason flexibly over the result, so you modeled the specific questions you meant to answer and built around them. Now the model raises the ceiling, and the work that decides how close you get to it lives in the context. The open question is no longer whether context is the lever, but how you wield it.</p><p>Wielding it is not the same as hoarding it. More context is not monotonically better; past a point it is actively worse. Performance on frontier models degrades as input grows, models favor what sits at the start and end of a long context over what’s buried in the middle, and even a single irrelevant document measurably hurts reasoning [4,5,6]. A bigger context window is not a bigger brain. So the goal is to gather everything and still hand the model only the right minimal slice. Every token earns its place.</p><p>Security makes the discipline acute. In software engineering the feedback loop is tight: you ship, a test passes or fails, and <strong>output is bound to outcome</strong> within minutes, or less. Security gets no such gift. A finding, an alert, a score sits a long, noisy distance from the outcome it is meant to anticipate. Most findings never become incidents, most incidents were never cleanly foretold, and the truth arrives late, partial, and contested. That gap is what the triage loop closes by hand, one finding at a time, and it is why the burden falls on context here more than almost anywhere. The how is the hard part.</p><h4>The bet: surface problems, or connect the dots</h4><p>Every security platform makes one decision before the first line of code, and everything else follows from it: what is the system for?</p><p>Most security products are built to surface a set of problems: a catalog of known misconfigurations, signatures, and policy violations, each evaluated against the facts its own policy needs. The best exposure-management and CNAPP platforms go further. They relate findings into attack paths, having understood years ago that security is a graph, and that the dangerous thing is usually a combination of conditions rather than any single finding. That is settled, and it is right. The shift that matters sits upstream of the graph, in what you decide to model.</p><blockquote>Every security platform makes one decision before the first line of code, and everything else follows from it: what is the system for?</blockquote><p>Even a platform that models the graph well usually models a bounded set of question-shapes: the ones its policies were written to evaluate. A connect-the-dots system models everything it can, so that any question is answerable, including the ones no policy anticipated like identities, cloud and infrastructure configuration, data, and network reachability. That’s because each of these bears on posture. Anyone can answer one cross-domain question by hand, given an afternoon. The <em>real</em> bar is whether the system answers them as a matter of course: can this identity reach this data store over a path that is actually open should resolve as a single join across one model, reliably, every time it’s asked?</p><p>There is a second boundary worth refusing, and it cuts against how the market talks. Everyone wants the same thing in the end: an enterprise security brain that reasons across the whole estate. That goal is exactly right. The open question is how you get there. The common assumption is that the brain gets smarter the more of one vendor’s portfolio you adopt. That is clean logic from the platform’s side, and it runs into something real on the enterprise’s side. No vendor owns the whole stack. Enterprises do not rip out the category leaders they have already bet on, in endpoint, cloud, identity, network access, to consolidate onto one. A platform whose understanding is bounded by what it has deployed is simply bounded, and ingesting another product’s findings does not lift that bound. A finding is a conclusion: a vendor’s verdict, frozen at the moment it was emitted, carrying only the evidence the vendor chose to keep. Reasoning over someone else’s conclusions is not the same as reasoning over the operating state and business context they were drawn from.</p><p>You cannot glue that brain together from portfolios and achieve optimal outcomes. It has to reason across all three at once: what the security tools conclude, the operating state beneath them, and the business context that decides which of it matters. A platform that reaches only the first has set its ceiling on the first day.</p><p>That single decision cascades into every layer: how data is acquired, how it is made intelligent, how it is retrieved, how it is kept coherent and governed. The architecture has to be built for inference, not for enumeration. And at every layer the same question recurs, the one a system built only to enumerate never has to ask: can I answer this by retrieval, or do I have to reason for it?</p><h3>Breadth: acquiring the world</h3><h4>Gathering at scale</h4><p>You cannot connect dots you never gathered, so the first cost is breadth. Breadth in security is brutal. The data lives everywhere, in every shape, and rarely under your control. This is not one hard problem but several stacked together, and the first is the shape of the cost itself. Adding a source is never a self-contained unit of work, because the value is not in the source but in how its entities relate to everything already there. Bring in a new population of identities, and each one has to be related to the roles, resources, and people you already hold. The work is many-to-many, not one-per-source. That combinatorial shape is the first reason hand-building integrations is a losing game.</p><p>Even the mechanical part is harder than it looks, and it is where many security companies quietly stall: extracting from an effectively unbounded set of systems, continuously, at scale, without drowning in maintenance. That only survives if you take the code out of onboarding. A new source should be brought in by describing it, declaratively, not by writing and maintaining a bespoke connector for every API in the world. Schema, not software. And the systems you pull from do not hold still. You control your own model; you do not control the upstream interfaces. An API breaks, deprecates a field, or changes shape the day a vendor ships a release. An authorization scope you had yesterday can be gone tomorrow. So acquisition is never a project that finishes. It is standing surveillance: watching every source for the moment it shifts out from under you, before a silent change corrupts everything downstream.</p><h4>Where the data has to live</h4><p>Where the data should live is a choice between two roads, and the honest answer is to take both. Most of it you want to bring home, consolidated where you can reason over it at full speed. But some of it is too large to move, too sensitive to copy, or bound by law to stay where it sits. For that, the only discipline-spanning option is to leave it in place and reason over it there, pulling back answers rather than data. A view that quietly drops everything inconvenient to move is not discipline-spanning at all.</p><p>Federation is also where the genuinely hard problem hides, the one most “we support your data” claims never reach. A customer’s own environment carries an ontology you did not design: a home-grown notion of a “service,” an ownership convention buried in a tag, a criticality tier or data classification that exists in no vendor’s catalog. Mapping known vendor schemas onto a model you control is the tractable part. Discovering that private ontology and folding it into the shared one, so the customer’s concepts and yours answer the same question together, is not.</p><h4>From data to meaning</h4><p>But pulling the data is only mechanics. The work that matters is making it mean something, and a source tells you almost nothing about meaning. It speaks in its own vocabulary. A row in it is just a row until the system can say what this thing is, what it represents, and what it relates to. That understanding has to be learned, not assumed. It can be inferred rather than hand-written, but inference that cheap cannot be trusted on faith, so nothing a machine proposes is believed until it earns belief, through checks that escalate from is this even well-formed to does it still hold against the live system. What you are building is a model of the source: something that explains the data on its own terms and reconciles into the single vocabulary the rest of the system speaks.</p><p>The first hard part is knowing when two records are the same thing. The same entity arrives under many names. Dana is an account in the identity provider, a mailbox in the mail system, a federated identity at an external provider, an owner: dana tag on a workload. Four records, one human. Until they collapse into a single node, a question that lives in the seam between two providers cannot even be asked.</p><p>Identity resolution like that has the clearest rules of the lot. Knowing how different things connect is the harder part: the edges, the synapses of the graph. That this identity can assume that role, that the role can read that store, that the store is reachable from that network node. These are rarely a clean foreign-key join waiting to be made. They are buried in unstructured configuration, in non-canonical representations, in conventions that differ by vendor and by resource type. An identity, a subnet, and a container do not describe themselves the same way, so the edge between them has to be inferred from how the pieces fit rather than looked up. Do that well and the modeled world is enormous. In production, ours spans more than a thousand kinds of nodes and over eleven hundred kinds of relationships, almost none of it handed to us, nearly all of it inferred.</p><p>And edges are only the first degree of it. On top of the modeled graph, the system derives intelligence that appears in no source at all: the blast radius of a resource, everything a foothold there could reach, and the attack vectors into it, the paths an adversary would actually take. Much of the security value lives in exactly these second- and third-degree questions, computed across the graph rather than read from it, and no easier to get right than the first degree.</p><p>There is no single way to build this intelligence, and there shouldn’t be. Open-source tooling, public frameworks, the security literature, and human-assisted generation are all fair game. What matters is the scoreboard: as much intelligence over the data as possible, produced as fast as possible, and right as often as possible on the first try, with people validating and correcting it so the next attempt is better. Speed here is a family of time-to-X metrics, from time-to-edge to time-to-blast-radius: how quickly a newly arrived fact becomes not a stored row but verified, usable intelligence. This understanding accumulates rather than appears. You do not build a discipline’s worth of modeled meaning in a day.</p><p>All of it is built offline, before any question is asked. Depth is where that intelligence is turned on individual resources, to say not just what could happen, but what matters here.</p><h3>Depth: turning data into intelligence</h3><h4>Contextualization</h4><p>Breadth fills the system with data. Making that data mean something is a separate job, and it is the point of everything that follows. The work has a name: contextualization. Take a resource and situate it, so that “an S3 bucket” becomes “a bucket holding customer records, readable by a dormant contractor’s role, reachable from the internet.” That is the unit of intelligence the whole system exists to produce. Everything else in depth serves to produce it well, cheaply enough to keep current, and in a form you can retrieve. In security, it has to carry the accuracy the domain demands, because a wrong context is not a rounding error. A missed privilege path is a missed incident. A phantom one is a team sent chasing a ghost, learning to distrust the tool.</p><p>Accuracy starts with order: deterministic, verifiable ground first, learned judgment only ever on top of it. That ground is not one signal but a ladder of them, each asking a sharper question than the last. An anomaly says look here: this resource stands apart from its peers. A failing control says a problem is actually present. An attack vector says it is not just present but reachable, the kind of thing an adversary could walk to. A blast radius says here is what it would cost if they did. None of these is asserted by a model. Each is read from the source of record or computed reproducibly over the graph, which is what lets everything above rest on it.</p><p>What that ladder still cannot tell you is whether any of it matters here. A perfectly exploitable path to a resource nobody depends on is noise. A smaller exposure on the system the business runs on is the alert that should have woken someone. The missing piece is semantics: what a resource is to the organization. This is where model reasoning earns its place, reading the business meaning the facts cannot carry on their own and letting it gate them rather than overrule them. So interpretation enters only as a modulation of the deterministic ground, within a deliberately narrow band. Let it run ahead of the facts and the system becomes confidently, unaccountably wrong. This is the separation between intrinsic exposure and contextual importance that we draw in our work on AI-native asset intelligence [7].</p><p>Two disciplines keep it honest. Signals that trace to one root weakness are a single exposure, not several stacked into a falsely louder one. And the same inputs have to yield the same understanding run to run, because a verdict that wobbles between runs is one nobody trusts twice.</p><h4>Doing the heavy work only where it counts</h4><p>Contextualization this rich is far too expensive to run from scratch on every resource at such breadth. There are too many of them, changing too often. The pyramid is what makes it affordable: the heavy work happens only where it is warranted, and ahead of time. The first move is clustering. Most resources are templated, one of ten thousand workloads stamped from the same mold, so the near-identical can be clustered and understood once, with each member inheriting the result.</p><p>Clustering also answers what to recompute, and when. The signal that matters is change. When the underlying data shifts, the question is whether it moved a resource out of the cluster it belonged to, and only what actually moved is recomputed. Never the whole estate on every small edit. The same clustering shows where the heavy, individual work belongs. A resource that still matches its cluster inherits an understanding already paid for. The ones that match nothing form clusters of their own and earn fresh, individual attention: the leftover nobody decommissioned, the instance configured by hand against every convention. That is disproportionately where real risk hides.</p><p>Getting that clustering right is one of the harder things the system does, because “the same” means different things on different axes, and the axes disagree. Sometimes you want sameness in the strict sense: identical configuration, identical shape, reproducible enough that the same inputs always land in the same cluster. An identity- or hash-based scheme serves that well. Other times you want likeness in meaning, where “close enough” is a matter of degree, better served by similarity in embedding space. Neither is right on its own, so the clustering works in more than one tier at once. And it has to do so agnostically: with a thousand kinds of resources and no per-type ground truth for what “the same” should mean, the system has to discover those boundaries for itself.</p><p>The dial that matters is how much disparity you absorb before two families share a single contextualization. Too loose, and a genuinely exposed resource hides inside a benign cluster that merely resembles it. Too tight, and you are back to contextualizing nearly everything from scratch. Keeping the clusters stable while the estate churns is what makes recomputing only the changes possible. If a small edit reshuffled every cluster, nothing would stay localized, and you would be re-deriving the world on every move.</p><h4>Search, and research</h4><p>All that contextualized understanding still has to be retrievable. That is the pyramid seen from the query side, a spectrum rather than two shelves. At the cheap end the work is already done and you simply retrieve it; the answer was shaped in advance. It is tempting to picture that as a pile of ranked text: ask, and get back the passage that answers you. But that is too small a picture. Many of the questions that matter are about paths, not passages. Which identities can reach this database is settled by walking edges, not ranking documents. So the curated end has to be walkable as well as searchable, and small enough, because it is curated rather than complete, to sit in an ordinary graph store and be traversed fast. As a question gets more novel, less of it has been answered in advance, and you slide toward the expensive end: multi-step reasoning, reconstruction, traversal of the full raw graph. Where a question lands depends on how much of the work that answers it has already been done. Most fall somewhere in the middle, partly precomputed, partly reasoned out on demand.</p><p>How you retrieve is itself a choice per question. Some are exact and want literal, sparse matching. Some are fuzzy and want similarity in embedding space. Some want both fused. Some are paths and want traversal. Not every point on the spectrum supports every mode, so how you prepare and embed data on the way up has to be decided around how you mean to retrieve it on the way down. Prepare it in a shape that does not fit the question, and no retrieval bolted on afterward will recover the answer. That alignment between preparation and retrieval is the first of two things that cannot be added after the fact.</p><h4>The flywheel</h4><p>Contextualization also pays a dividend that is easy to miss. Every time the system contextualizes a resource, it tends to surface relationships that were not explicit before: that this exposure reaches that asset, that these two findings share a cause. Once those pass the same validation as everything else, they are curated into the layer the next question is answered against, so it has more to reason over than the last. The better and more validated the data already is, the more the next pass can infer from it; the more it infers, the better the data becomes. Every validated turn is something a later competitor has to accumulate from scratch.</p><p>It is fragile in a specific way. A flywheel amplifies whatever you feed it, so an unvalidated guess compounds into error exactly as fast as a verified fact compounds into signal. Which is why validation is not a step you skip for speed, and not purely automatic. A learned relationship is trusted only after it is checked against deterministic ground, and, where the stakes are highest, against a person who reviews and corrects what the model proposed. An inferred path that a deny policy forbids is thrown out before it can become the silent premise of everything built on top of it.</p><p>None of this is ever finished, because the world it describes keeps moving, and curated understanding is only worth as much as it is current. That puts the weight back on the base of the system.</p><h4>Performance: a base layer that reasons</h4><p>Breadth and depth describe what the system holds and understands. Performance is what makes it usable the moment a question arrives. The demand lands hardest at the base of the pyramid, on the largest, rawest, most connected data.</p><p>The same spectrum that governs retrieval governs storage. The closest analogy is a processor’s memory hierarchy: a small amount of hot, fast memory close to the work; vast cold storage farther away; and the whole art lies in deciding what lives where.</p><p>The naive answer is to make everything hot: load all relationships into the fast tier and pay the cost. At the scale of a discipline, that is neither affordable nor possible. The more interesting move is the opposite: make the cold tier intelligent enough to participate in reasoning.</p><p>That shift is now possible because the foundations of large-scale analytics have changed. Cheap object storage is no longer just an archive. Columnar layouts, open table formats, metadata indexes, partition pruning, predicate pushdown, and vectorized execution have turned lakehouse-style storage into an active query substrate. The remaining step is not simply to run SQL over it, but to expose it in the language of the domain: relationships, paths, neighborhoods, and traversals.</p><p>In other words, the base of the pyramid should not require being loaded into a conventional graph database before it can be reasoned over. Graph databases are genuinely good, and they are exactly what belongs in the hot, curated layer near the top of the hierarchy. But the base is a different problem. There, the right abstraction is an optimized graph query engine that can execute graph-native dialects directly over the cold store, allowing Cypher-like traversal semantics over columnar, partitioned data without first materializing the entire graph into a dedicated serving database.</p><p>In our production deployment, this approach runs past 500 billion edges at sub-second average query latency on real, partition-pruned traversal workloads. That is the claim that matters: at the scale of an entire discipline, the base of the pyramid should be reasoned over, not merely stored.</p><h4>A graph you can trust</h4><p>Scale lets you reason over the graph. It does not, by itself, let you trust what you reason over. Two more properties do, and neither is about speed. Both have to be true of every edge, enforced in the substrate as the query runs, and neither can be added once the rest is built.</p><p>The first is coherence in time. Every edge and every resource carries the revision of the extraction that produced it. The naive mental model, “query the graph as of revision r,” is wrong, because there is no single revision for the whole graph. Different sources extract on different cadences, so revision lives at the granularity of individual resources and edges, and an edge is coherent only when its endpoints carry revisions that line up. Stamping a version on things is the easy part. The real work is assembling the most recent coherent snapshot, at query time and at speed, out of millions of independently-revisioned parts. The engine reads only the slices a traversal needs, pruning hard on revision so it never touches what doesn’t belong to the question. The payoff is escaping the quagmire of inconsistent state. Without coherent revisions, a traversal reads a smear of half-updated world, and the team ends up arguing over whether a finding is real or just an artifact of one source running a cycle ahead of another. It also makes a working memory feasible. With revisions to anchor it, the system keeps a coherent recent slice hot and lets the rest age into cold storage, evicting safely because nothing it serves depends on a half-updated mix.</p><p>Since the store retains immutable, time-stamped snapshots rather than overwriting in place, it also keeps what it held before. A question about the past is answered by reading a retained snapshot instead of reconstructing history by hand. (Separating when something was true in the world from when the system came to know it is subtler still. The snapshots give you the second cleanly).</p><p>The second is access, and not the basic kind. Keeping one customer’s data from another’s is table stakes, really a matter of authentication. The harder reality is that inside a single enterprise, not everyone should see everything. A viewer may be entitled to some integrations and not others, and the graph has to honor that as it reasons, not after. This is a degree harder than row-level access control. The unit you are authorizing is the edge, the synapse, not the row, and it has to hold mid-traversal rather than at the end. So an edge carries more than a revision. It carries the scope it came from. Who may traverse it is enforced as the query runs, with guards injected into the traversal before it executes, so an edge outside the viewer’s scope, or outside the coherent snapshot, is never visited and never shapes the answer. That is a different design, with a different failure mode, from scrubbing a forbidden fact out of an answer after it has already shaped everything computed along the way. Bolt analytics onto a storage tier and you get a faster archive. You get a substrate you can reason over, coherently and safely, only when these are properties of how the foundation was laid.</p><h3>Measuring what you can’t take on faith</h3><p>Everything to this point runs on model reasoning, and model reasoning is not deterministic. The capabilities here are tuned tightly to the behavior of specific models, and that behavior moves: the same question can take a different path tomorrow than it took today, and a single model upgrade can shift the ground beneath a feature that worked the day before. You are trading accuracy against efficiency, cost, and impact on every call, and none of those trades holds still. So you cannot take the system’s output on faith. The gap between output and outcome that makes security so unforgiving will not close on its own.</p><blockquote>The model was never the scarce part. The context to reason over was, and that is the part you can only build in.</blockquote><p>Engineering has long had a blunt version of this discipline: if it isn’t tested, it doesn’t exist. For capabilities fitted this closely to models that drift, the bar is higher. In context engineering, and far more so in security, if it isn’t benchmarked, it doesn’t exist. A capability you cannot measure end to end, from real data through the whole system to a verifiable answer, is one you are taking on faith, and faith is what the domain does not allow.</p><p>So the machinery of measurement is a first-class citizen of the platform, not a QA afterthought bolted on near release. The datasets, the graders, the harnesses that turn a natural-language question into executable steps and check the answer against production-grade infrastructure deserve the same engineering seriousness as the query engine or the storage layer. They are what tells you whether the rest is still working as the data and the models beneath it move. And what you measure matters as much as that you measure. Score the path, not only the answer, because a right answer reached by a brittle, extravagant route will not survive scale or change. Test across vendors rather than within one, because the question that matters usually lives in the seams between them, where single-vendor evaluation cannot see it. This is work we build, run continuously, and publish, so the method can be checked and improved on [8]. In our own cross-vendor benchmark, holding the models and task set fixed and varying only the context raised correctness while sharply cutting the agent’s exploration queries, so better-curated context proved both cheaper and more correct [9].</p><h3>You build it in, or you rebuild</h3><p>Be plain about the size of what this is. A platform that connects the dots is not a sharper point solution, and it is not a dozen point solutions wired together. It is a different kind of system, and its decisive choices are made before the first line of code. The alignment between how data is prepared and how it is retrieved; the substrate that stays coherent and governed beneath every query; the understanding that deepens with every validated pass: none of these is a module you attach later. Each was a fork in the road, taken at the start. That is why a platform built to enumerate known problems can be excellent at its job and still never close the triage loop. The work it cannot do was designed out on day one.</p><p>Pay that price up front, though, and the LLM era turns from a threat into leverage. The triage loop closes. Analysts spend their hours deciding instead of reassembling. A system that once produced alerts begins to produce understanding. The model was never the scarce part. The context to reason over was, and that is the part you can only build in.</p><p>So the real choice was never which features to buy. A point solution is something you ship. A system that reasons over an entire discipline is something you accumulate, decision by decision, edge by validated edge, year over year. Its advantage compounds the whole time, and the years are the one thing a rebuild can never give back.</p><h3>References</h3><p>[1] Anthropic, “Effective context engineering for AI agents.” <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents">https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents</a></p><p>[2] The New Stack, “The Real Bottleneck in Enterprise AI Isn’t the Model, It’s Context.” <a href="https://thenewstack.io/the-real-bottleneck-in-enterprise-ai-isnt-the-model-its-context/">https://thenewstack.io/the-real-bottleneck-in-enterprise-ai-isnt-the-model-its-context/</a></p><p>[3] Microsoft Security Blog, “Empowering defenders in the era of agentic AI with Microsoft Sentinel” (September 30, 2025). <a href="https://www.microsoft.com/en-us/security/blog/2025/09/30/empowering-defenders-in-the-era-of-agentic-ai-with-microsoft-sentinel/">https://www.microsoft.com/en-us/security/blog/2025/09/30/empowering-defenders-in-the-era-of-agentic-ai-with-microsoft-sentinel/</a></p><p>[4] K. Hong, A. Troynikov, J. Huber, “Context Rot: How Increasing Input Tokens Impacts LLM Performance,” Chroma Technical Report, July 2025. <a href="https://research.trychroma.com/context-rot">https://research.trychroma.com/context-rot</a></p><p>[5] N. F. Liu et al., “Lost in the Middle: How Language Models Use Long Contexts,” TACL 2024. <a href="https://arxiv.org/abs/2307.03172">https://arxiv.org/abs/2307.03172</a></p><p>[6] F. Shi et al., “Large Language Models Can Be Easily Distracted by Irrelevant Context,” ICML 2023. <a href="https://arxiv.org/abs/2302.00093">https://arxiv.org/abs/2302.00093</a></p><p>[7] G. Engelberg, L. Goldberg, K. Koutsyi, et al., “AI Native Asset Intelligence.” <a href="https://arxiv.org/abs/2605.09115">https://arxiv.org/abs/2605.09115</a></p><p>[8] G. Engelberg, K. Koutsyi, L. Goldberg, et al., “Sola-Visibility-ISPM: Benchmarking Agentic AI for Identity Security Posture Management Visibility.” <a href="https://arxiv.org/abs/2601.07880">https://arxiv.org/abs/2601.07880</a></p><p>[9] E. Yavin, G. Engelberg, K. Koutsyi, L. Goldberg, G. Baron, “Cross-Vendor Sola ISPM Benchmark: Evaluating Agentic AI for Federated Identity Security Reasoning.” <a href="https://arxiv.org/abs/2606.02674">https://arxiv.org/abs/2606.02674</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a70e36636787" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sola-security/context-is-the-architecture-rethinking-security-platforms-in-the-llm-era-a70e36636787">Context is the Architecture: Rethinking Security Platforms in the LLM Era</a> was originally published in <a href="https://medium.com/sola-security">Sola Security</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Generating Integrations At Scale]]></title>
            <link>https://medium.com/sola-security/generating-integrations-at-scale-b9f1a841a15c?source=rss----3b49f145bb43---4</link>
            <guid isPermaLink="false">https://medium.com/p/b9f1a841a15c</guid>
            <category><![CDATA[engineering-productivity]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Itay Waisman]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 08:31:36 GMT</pubDate>
            <atom:updated>2026-02-19T13:01:56.066Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DeB3QLh3NzE3cUjPUuDbyw.png" /></figure><ul><li>Sola has managed to reduce dev time of new integrations from 4–5 days to a few hours</li><li>We leverage json schema to enforce structured outputs</li><li>Three-layer validation (syntax → semantic → runtime) creates a comprehensive validation solution which is automatable.</li><li>Accumulated configs become a dataset that compounds: RAG, few-shot learning, eventual fine-tuning</li><li>Accumulated “faulty” generations and validations in runtime, become a semantic knowledge set that can help future generations</li></ul><h3>Integrations are challenging</h3><p>Many companies face similar challenges when implementing their integration solution — building integrations rapidly but with maximal quality. Integrations are a special use case for LLM generation, as they require implementation for a lot of moving parts, while still maintaining high correctness.</p><p>Quality in integrations is almost “binary”, either data extraction from an API works, or it doesn’t. It can also manifest in ways above functionality, like performance. Extracting data from APIs at scale is hard, and even when assuming you have the infrastructure in place to handle it, making AI generated code adapt to it is hard.</p><p>I’d like to present our engineered solution, which can be generalized to a generic “design pattern” for similar problems. This solution consists of pre-existing ideas being implemented, built into a “repeatable” system that provides great value in terms of quality and speed of generated artifacts.</p><p>Moreover, as we’ll see, this solution has the benefit of improving itself over time, as generated outputs are always structured similarly and validated to a high extent.</p><h3>The Measurable Impact</h3><p>Before building this, new integrations at Sola <strong>took 3–5 days</strong> of engineering time (at best). Each integration was implemented manually (or with a coding agent), but more importantly was tested manually for auth handling, pagination logic, error cases etc. Production bugs were common: missing rate limits, incorrect field mappings and various edge cases in pagination.</p><p>The solution we implemented reduced the time it takes to create a working and validated integration to <strong>only a few hours</strong>. This also helped with reducing production bugs, as the generated code ran on deterministic, reliable infrastructure.</p><h3>A naive approach: free-form code generation</h3><p>A naive approach to building integrations is letting Claude Code have a go at it, and generate free form code. At the end, if an integration works why should we care how it is implemented?</p><p>Here are examples of free-form code handling the same authentication logic:</p><pre># What the AI might generate (version 1)<br>def authenticate(api_key):<br> return {&quot;Authorization&quot;: f&quot;Bearer {api_key}&quot;}<br># What it might generate (version 2)<br>def authenticate(credentials):<br> token = credentials.get(&quot;token&quot;)<br> return {&quot;Authorization&quot;: f&quot;SSWS {token}&quot;}<br># What it might generate (version 3)<br>class OktaAuth:<br> def __init__(self, api_key):<br> self.api_key = api_key<br> def get_headers(self):<br> # … 20 lines of invented OAuth logic …</pre><p>The main challenge with free-form code, is that it’s harder to validate it and ensure the quality of outputs. There is no guaranteed structure, beside the language itself. Enforcing semantics is a lot harder this way. The only way to validate this is at runtime.</p><p>Validation capabilities means correctness at scale, and the lack of them will greatly harm our ability to create more integrations and maintain them.</p><p>Moreover, this will probably be integrated into your system. This usually means you need to define an API between the generated code and the wrapping system, which is already the beginning of the structure we try to enforce.</p><h3>DSL based Autonomous Feedback Loop</h3><p>Let’s break the solution down into the different components needed.</p><h4>The programmable executor</h4><p>The basic component of our solution is building an executor component, which is programmable using a DSL. In plain terms, this for us is:</p><ol><li>A deterministic, reliable and tested typescript library with a main entry point.</li><li>Given a json configuration, and structured json context, it outputs extracted items.</li><li>The configuration has a json schema — this is the DSL.</li><li>We use <a href="https://zod.dev/">zod</a> to define the DSL in code, and convert it to json schema.</li></ol><p>Here is an example of a configuration, for a sub-section of the whole config responsible for defining the authentication to an API:</p><pre>{<br> &quot;authentication&quot;: {<br> &quot;type&quot;: &quot;bearer&quot;,<br> &quot;bearerPrefix&quot;: &quot;SSWS&quot;,<br> &quot;token&quot;: &quot;$.credentials.token&quot;<br> }<br>}</pre><p>And here is the underlying, constraining json schema:</p><pre>{<br>  &quot;authentication&quot;: {<br>   &quot;type&quot;: &quot;object&quot;,<br>   &quot;required&quot;: [&quot;type&quot;],<br>   &quot;properties&quot;: {<br>     &quot;type&quot;: {<br>       &quot;enum&quot;: [&quot;bearer&quot;, &quot;apiKey&quot;, &quot;oauth2&quot;, &quot;basic&quot;]<br>      },<br>      &quot;bearerPrefix&quot;: {<br>        &quot;type&quot;: &quot;string&quot;,<br>        &quot;description&quot;: &quot;Optional prefix like &#39;Bearer&#39; or &#39;SSWS&#39;&quot;<br>      },<br>      &quot;token&quot;: {<br>        &quot;type&quot;: &quot;string&quot;,<br>        &quot;description&quot;: &quot;JSONata expression to extract token from context&quot;<br>      }<br>    },<br>    &quot;if&quot;: {<br>      &quot;properties&quot;: { &quot;type&quot;: { &quot;const&quot;: &quot;bearer&quot; } }<br>    },<br>    &quot;then&quot;: {<br>      &quot;required&quot;: [&quot;token&quot;]<br>    }<br>  }<br>}</pre><p>It defines a clear and constrained API to “program” our library. This will be useful to reduce syntax hallucinations. Moreover the structure in itself provides context to the Agent to what “features” the library supports.</p><p>By using descriptions for each field — you can attach even more context to users and agents, when it’s not possible to provide it through the schema.</p><p>Let’s call this the “executor”.</p><h4>Side note — JSONata</h4><p>The keen eyed of you noticed an interesting syntax: “$.credentials.token”. This is our way to make the configuration more of a “template”, and is the way for the executor to be able to “run” the provided config with a given context json object.</p><p>We use JSONata which is useful both when “injecting” values into the config, as well as extracting values from the output.</p><h4>The Agent</h4><p>To complement it, and reduce the headache of configuring manually a bunch of integrations, we define an AI Agent:</p><ol><li>An AI Agent using your favorite framework, or even Claude Code.</li><li>Give it common tools, such as web search and documentation related parsing.</li><li>You limit the output of the agent using the DSL definition, by attaching the json schema to the system prompt (or asking the agent to read it himself).</li><li>The agent has a feedback loop — it tries to validate the output against the provided schema and can auto correct itself.</li></ol><p>This by itself is not a new idea — <strong>langchain</strong>, a popular agent development framework, allows you to attach “<a href="https://docs.langchain.com/oss/python/langchain/structured-output">structured output</a>” constraints using <a href="https://docs.pydantic.dev/latest/">Pydantic</a>. It also doesn’t mean we achieve high correctness, as generated configurations can be valid syntax-wise but break in reality.</p><h3>The Validation Pyramid: Three Layers of Correctness</h3><p>Here’s where the architecture gets interesting. The DSL enables validation at a basic syntax level. This is in most cases not enough, as syntax does not guarantee correctness when used in reality.</p><p>We need to introduce a few more validation “layers”, each building on the layers below it to increase the quality of generated output.</p><p>Another key aspect to this pattern is ensuring that it is extendable. We need to be able to extend each layer over time in order to:</p><ol><li>Support more features — we may want to introduce a new authentication mechanism, or a new pagination scheme.</li><li>Handle more edge cases we saw in production, and avoid known bugs</li></ol><p>The current extra 2 layers we added, beside the syntax validation layer, are:</p><ol><li>Semantic validation</li><li>Runtime validation</li></ol><p>You may want to introduce more layers as you see fit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*YFsTz84z4Mzic5YUAVImtA.png" /></figure><h4>Layer 1: Syntax Validation (JSON Schema)</h4><p>As discussed, this layer catches structural errors before any code is executed. The schema defines the “legal” possibility space, ensuring the AI cannot invent non-existent fields or invalid types. It is also the fastest — provide a json schema validation tool to the agent, and it can validate itself in microseconds.</p><ul><li><strong>What it catches</strong>: Missing required fields, invalid enums, or type mismatches.</li><li><strong>How to implement: </strong>use json-schema or langchain’s structured outputs.</li><li><strong>Micro-Example</strong>:</li></ul><pre>Error: /pagination missing required property ‘cursorPath’ (Required when type is ‘cursor’)</pre><h4>Layer 2: Semantic Validation (Domain Rules)</h4><p>Syntax validation ensures the “form” is filled out correctly; semantic validation ensures the form <strong>makes sense</strong>. This is static analysis for your DSL that encodes your team’s specific integration expertise.</p><p>A few examples:</p><ol><li>The generated config is trying to extract a collection of items from an endpoint, but is missing the “pagination” scheme.</li><li>An integration that is extracted incrementally (i.e. only the changes, or the “delta” are fetched on each iteration) but is using the “createdAt” field instead of “updatedAt” — this means updates will not be extracted.</li></ol><ul><li><strong>What it catches</strong>: Logical inconsistencies, such as a “list” operation missing pagination or an auth type that doesn’t match the base URL.</li><li><strong>How to implement:<br></strong>We created a set of rules, defined as code functions. This can even be a pytest test suite that the agent can run. Each “test” validates the generated output.<br>LLM-as-a-judge: A cool approach I saw is to have another agent with a prompted set of rules, that can validate the output, but taking the context of each case into consideration.</li><li><strong>Micro-Example</strong>:</li></ul><pre>Warning: GET requests for ‘list’ operations should include a pagination block, otherwise we do not extract all items.</pre><h4>Layer 3: Runtime Validation (Black-Box Testing)</h4><p>The final check executes the generated configuration against a sandbox environment. This confirms that the AI’s “theory” about the API matches the actual reality of the external service.</p><ul><li><strong>What it catches</strong>: API contract mismatches, hallucinated field paths, and environment-specific issues like auth token expiration.</li><li><strong>How to implement: </strong>provide the agent with a test environment and “run” the configuration live using your executor.</li><li><strong>Micro-Example</strong>:<br>Exit code: 1 — API response 403 — Invalid token. Check credential mapping.</li></ul><h3>The Dataset Flywheel: Learning from Accumulated Examples</h3><p>Here’s the second-order effect that makes this architecture compound over time: <strong>every valid config is a training example.</strong></p><p>By leveraging well-known techniques like RAG and few-shot learning, measurable improvements can be seen fast.</p><p>Another interesting accumulation of knowledge possible with this approach — the semantic validation layer can <strong>expand over time</strong>. By instructing the agent to ק“store” semantic rules for future validations, when it encounters an error in the layer above it (the runtime layer), we are able to “push-down” validation to an earlier step. If possible, pushing the validation into the syntax layer is even better, for example using field descriptions.</p><p><strong>The more integrations you build, the better the AI gets at generating new ones.</strong> The schema creates the consistency that enables learning.</p><h3>Tradeoffs &amp; Limitations: Where This Breaks</h3><p>No architecture is perfect. Here’s where the DSL approach shows its seams, and when you should consider alternatives.</p><h4>Upfront Investment Is Real</h4><p>Building a DSL requires:</p><ul><li>Designing the schema (identifying building blocks, encoding constraints)</li><li>Implementing the executor (generic runtime that interprets configs)</li><li>Writing validators (semantic rules beyond JSON Schema)</li><li>Creating good error messages (the teaching materials for AI)</li></ul><p>For our integrations DSL, this took ~2–3 weeks of focused work.</p><p>In my opinion, this paradigm enforces <strong>good software engineering practices.</strong> Which is the natural way you would try to implement this anyways:</p><ol><li>Introducing validated structure — can even be a class hierarchy</li><li>Create a validation procedure — introduce testing, on multiple levels.</li><li>Try to build it to be extendable, to be able to introduce more integrations.</li></ol><h4>Hard Cases Expose DSL Boundaries</h4><p>Some integrations don’t fit the mold:</p><ul><li><strong>Custom auth flows</strong>: Some APIs use exotic auth (multi-step OAuth with device codes, SAML, custom signature schemes). You either extend the schema (bloat) or special-case them (complexity).</li><li><strong>Complex transformations</strong>: When JSONata isn’t enough and you need real code (API returns XML, requires crypto operations, needs stateful logic).</li><li><strong>Vendor-specific quirks</strong>: Jira’s API does something no other API does. Do you add a <em>jiraSpecialCase</em> field (schema bloat) or write custom code (defeats the purpose)?</li></ul><p><strong>Our approach</strong>: 95% of integrations fit the DSL cleanly. For the other 5%, we allow an escape hatch, custom TypeScript plugins that the executor can call. This keeps the DSL clean while handling edge cases.</p><h4>JSONata: Not Quite Code, Not Quite Data</h4><p>JSONata is powerful, maybe too powerful. Without guardrails, it can become “code in disguise”:</p><p>“$reduce($.items, function($acc, $item) {$acc + ($item.price &gt; 100 ? $item.price * 0.9 : $item.price)}, 0)”</p><p>This is functional programming hidden in JSON. Debugging is painful, testing is hard, and you’ve lost the declarative benefits.</p><p><strong>Rule of thumb</strong>: If your JSONata expression needs comments to explain it, extract that logic into a custom plugin instead.</p><h3>The Bigger Picture: Beyond Integrations</h3><p>This pattern works beyond API integrations.</p><p><strong>Look for these signals:</strong></p><ul><li>You’re writing similar code repeatedly with well defined variations</li><li>Correctness is critical (production systems, security-sensitive code)</li><li>Review is expensive (complex logic, many edge cases)</li><li>You have expertise to encode (you know the patterns, you’ve debugged the failures)</li></ul><p>The pattern allows you to engineer a system that:</p><ol><li>Allows automation of creation and debugging bugs</li><li>Is expandable over time for more features</li><li>Is expandable over time for hard-earned knowledge from production.</li></ol><p>I encourage you to try this approach and share more “design patterns” that work for your use cases.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9f1a841a15c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sola-security/generating-integrations-at-scale-b9f1a841a15c">Generating Integrations At Scale</a> was originally published in <a href="https://medium.com/sola-security">Sola Security</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Minutes to Seconds: Achieving “Live Reload” for AWS ECS]]></title>
            <link>https://medium.com/sola-security/from-minutes-to-seconds-live-reload-aws-ecs-961a4c3bb875?source=rss----3b49f145bb43---4</link>
            <guid isPermaLink="false">https://medium.com/p/961a4c3bb875</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devex]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[fargate]]></category>
            <dc:creator><![CDATA[Eli Mutchnik]]></dc:creator>
            <pubDate>Thu, 05 Feb 2026 13:35:55 GMT</pubDate>
            <atom:updated>2026-02-05T13:35:57.210Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rf9BCqnLEbQxnZXJQ_VcVw.png" /></figure><p>There is a specific kind of pain known only to developers working with containerized microservices.</p><p>We loved our architecture: Docker images running on ECS Fargate at a remote environment orchestrated by Terraform, cleanly separated services, and reproducible infrastructure. But we hated the <strong>waiting game</strong>.</p><p>Every time we changed a line of code, the tax was paid in minutes per service which sums to tens of minutes overall.</p><p><strong>For each service the deploy process was:</strong></p><p><strong>[Build]</strong> the new Docker image → [<strong>Push]</strong> to registry → [<strong>Deploy]</strong> new ECS task definition with the new image → [<strong>Wait]</strong> for the ECS task to provision → [<strong>Test]</strong> and make additional code changes.</p><p>It felt like a massive waste of developer’s time. We realized that if we wanted to keep our velocity, <strong>we had to hack that loop</strong>. We needed to go from minutes of deployment time to <strong>seconds of live updates.</strong></p><p>Here is how we did it.</p><h3>The Vision: Frontend-Style Live Reloading for ECS Fargate Containers</h3><p>If you have ever done frontend development, you know the joy of Hot Module Replacement (HMR). You save a file, and the browser updates instantly.</p><p>Our goal was to bring that same “Live Reload” experience to our heavy, containerized Python and Node.js backend services running on AWS ECS Fargate. We wanted to update the code inside the running container <strong>without</strong> triggering a new deployment and <strong>without</strong> replacing the ECS task.</p><h3>The Challenge: Getting code into a running container</h3><p>We needed a pipeline that looked like this:</p><ol><li><strong>Local Watcher:</strong> Detects file changes on the developer’s machine.</li><li><strong>Transport:</strong> Ship the code to the cloud instantly.</li><li><strong>Reflector:</strong> The container detects the change and restarts the server process.</li></ol><h3>Initial attempt: The Naive EFS Mount (And why it failed)</h3><p>Our first thought was simple: Let’s just use AWS EFS.</p><p>We tried mounting an EFS volume directly to the developer’s local machine and, simultaneously, to the ECS task. In theory, I save a file locally, and it appears in the cloud.</p><p><strong>The reality:</strong> It was painfully slow and unstable. Network latency made working on the mounted drive feel sluggish, and file locks became a nightmare. We realized that mounting cloud storage locally was a dead end.</p><h3>The Solution: The “Broker” Pattern</h3><p>We didn’t need a two-way sync. We needed a lightning-fast, one-way injection of code.</p><p>We architected a solution using an <strong>EC2 “Broker” instance</strong>. Here is the flow:</p><ol><li><strong>The Developer</strong> works on their local machine.</li><li><strong>The Local Watcher </strong>uses<strong> rsync </strong>and pushes <em>only the file deltas</em> to an EC2 broker instance.</li><li><strong>The EC2 Instance</strong> has the EFS drive mounted to it.</li><li><strong>The ECS Task</strong> has that <em>same</em> EFS drive access point mounted as a volume.</li></ol><p>By using rsync, we aren’t transferring the whole repo — just the bytes that changed. The EC2 acts as a high-speed bridge, writing directly to the EFS mount that the container is reading from. So eventually, after the developer hits save in its IDE, the changes appear <strong>in seconds</strong> in the target container.</p><h3>The Implementation Stack</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wqo91Tp9jJ3CuUAHRfdQUw.png" /></figure><p>To make this seamless for our developers, we glued it together with a few key tools:</p><h4>1. The Local Watcher</h4><p>Since we work in a monorepo managed by <a href="https://nx.dev/"><strong>nx</strong></a>, we utilized the <a href="https://nx.dev/docs/reference/nx-commands#nx-watch"><strong><em>nx watch</em></strong></a> command. It listens for file changes in specific projects and triggers our sync script.</p><p>To keep this tidy, we wrapped the watch command in <a href="https://pm2.keymetrics.io/"><strong>pm2</strong></a>. This gives developers a nice monitoring experience to see which services are currently “syncing” and provides logs if a sync fails.</p><h4>2. The Sync</h4><p>When <em>nx watch</em> fires, it executes a script that will calculate what exactly needs to be synced and does it via <a href="https://linux.die.net/man/1/rsync"><strong>rsync</strong></a> command. It pushes the files to a dedicated path on the EC2 broker that corresponds to the specific service and developer environment (e.g., /efs/user-dev/service-a).</p><h4>3. The Container Restart</h4><p>Once the file lands in the ECS container (via the EFS mount), the application needs to notice the change and restart.</p><p><strong>For Python:</strong> This was easy. We leveraged <a href="https://uvicorn.dev/"><strong>uvicorn</strong></a> which already supports live reloading. We simply updated our entry point:</p><pre>uvicorn main:app --reload --reload-dir /app/code</pre><p><strong>For Node.js (TypeScript):</strong> This was harder. The standard node <em>watch</em> flag relies on <em>inotify</em> events (signals sent by the OS when a file changes). However, because the file change was happening on the EFS mount (technically outside the container’s OS), <em>inotify</em> events often didn’t trigger reliably.</p><p>We solved this with <a href="https://github.com/watchexec/watchexec"><strong>watchexec</strong></a>. It is a fantastic, cross-platform tool that polls for file changes and handles the restart robustly, even across network mounts.</p><pre>watchexec --poll 1000 --debounce 1000 --restart --watch /app/code/index.js \ <br>-- node /app/code/index.js</pre><h3>The Result</h3><p>We provided via an internal CLI the ability to watch and sync every task in every service and the difference was night and day.</p><ul><li><strong>Before:</strong> Change code → Wait <strong>5 minutes</strong> for Terraform → Test.</li><li><strong>After:</strong> Change code → Wait <strong>5 seconds</strong> for rsync + Restart → Test.</li></ul><p>We didn’t just save time; we saved our focus. By removing the friction of deployment, we returned to the “flow state” that makes development enjoyable.</p><p>If you found yourself nodding along to the pain I described at the start, you might be wondering if building this architecture is worth the engineering effort.</p><p>I challenge you to perform a quick calculation right now. Run these numbers for your organization:</p><blockquote><strong><em>{</em></strong>Number of Developers<strong><em>}</em> <em>X</em> <em>{avg</em></strong> Changes Per Day<strong><em>}</em> <em>X</em> <em>{</em></strong>Build and Deploy Time<strong><em>}</em> = <em>The amount of time you are about to save.</em></strong></blockquote><p>The result isn’t just “saved minutes.” It is the amount of time your team currently spends staring at progress bars instead of building features. It is the cost of context switching and lost momentum. We realized we couldn’t afford <strong><em>not</em></strong> to fix it. If your number looks anything like ours did, <strong>neither can you</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=961a4c3bb875" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sola-security/from-minutes-to-seconds-live-reload-aws-ecs-961a4c3bb875">From Minutes to Seconds: Achieving “Live Reload” for AWS ECS</a> was originally published in <a href="https://medium.com/sola-security">Sola Security</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>