<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Alex Georghiou</title>
    <description>The latest articles on DEV Community by Alex Georghiou (@alexgeorghiou).</description>
    <link>https://dev.to/alexgeorghiou</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4258978%2Ffea7b5cf-2b65-40ef-9693-bba7b065d8a2.jpg</url>
      <title>DEV Community: Alex Georghiou</title>
      <link>https://dev.to/alexgeorghiou</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/alexgeorghiou"/>
    <language>en</language>
    <item>
      <title>Software Architecture After the AI Shortcut</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Fri, 06 Nov 2026 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/software-architecture-after-the-ai-shortcut-504e</link>
      <guid>https://dev.to/alexgeorghiou/software-architecture-after-the-ai-shortcut-504e</guid>
      <description>&lt;h1&gt;
  
  
  Software Architecture After the AI Shortcut
&lt;/h1&gt;

&lt;p&gt;Generating code is getting easier. Understanding the consequences of code is not.&lt;/p&gt;

&lt;p&gt;A model can produce a controller, repository, client, and tests in minutes. It cannot infer operational requirements that nobody articulated: who may call the endpoint, what level of inconsistency is acceptable, which failures require manual recovery, or what must be recorded for an audit.&lt;/p&gt;

&lt;p&gt;This shifts the architect's attention toward boundaries and evidence. Define contracts before producing implementations. Specify invariants, failure budgets, authorization checks, and observability. Then use generated code as something to inspect and verify rather than something to trust because it compiles.&lt;/p&gt;

&lt;p&gt;One of the most revealing reviews is to ask for the failure path: a downstream service returns slowly, a retry overlaps with a second request, a user loses access halfway through the operation, and the database commits just before a cancellation. What does the generated application do?&lt;/p&gt;

&lt;p&gt;I do not think architecture is disappearing into prompts. I think weak architecture is becoming easier to produce at scale. The scarce skill remains deciding which constraints matter and proving the software respects them.&lt;/p&gt;

&lt;p&gt;The engineer who can explain trade-offs, failure modes, and operational behavior will remain more valuable than the engineer who can produce the longest diff.&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>ai</category>
      <category>engineering</category>
    </item>
    <item>
      <title>The Architecture Review I Want Before Shipping an Agent</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Wed, 19 Aug 2026 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/the-architecture-review-i-want-before-shipping-an-agent-2l4l</link>
      <guid>https://dev.to/alexgeorghiou/the-architecture-review-i-want-before-shipping-an-agent-2l4l</guid>
      <description>&lt;h1&gt;
  
  
  The Architecture Review I Want Before Shipping an Agent
&lt;/h1&gt;

&lt;p&gt;An architecture review for an agent should spend less time on model rankings and more time on authority, data, and failure.&lt;/p&gt;

&lt;p&gt;I want to see the tool inventory, with every action classified as read-only, reversible, or high impact. I want to know where authorization is enforced, how untrusted retrieved text is handled, and what happens when the model asks for something outside the permitted contract.&lt;/p&gt;

&lt;p&gt;Next comes data flow. Which documents enter context? Can one tenant's information reach another? What is retained in logs? How are deleted or corrected records removed from retrieval indexes? A neat agent graph does not answer these questions.&lt;/p&gt;

&lt;p&gt;Then I inspect recoverability. Can we replay a failed step safely? Are retries bounded? Can we distinguish a command that failed from one that succeeded without returning? Is human approval a first-class state transition?&lt;/p&gt;

&lt;p&gt;Finally, evaluation. Show me realistic tasks, negative cases, and failures observed during testing. Show me the result of changing a prompt or tool schema, not just a demo in which everything worked.&lt;/p&gt;

&lt;p&gt;A review is useful when it produces explicit decisions: accepted risks, owners, checks, and rollback conditions. If the meeting ends with "the model seems good," no architecture decision has really been made.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>security</category>
    </item>
    <item>
      <title>Your AI Workflow Needs an Idempotency Boundary</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Tue, 05 May 2026 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/your-ai-workflow-needs-an-idempotency-boundary-3plm</link>
      <guid>https://dev.to/alexgeorghiou/your-ai-workflow-needs-an-idempotency-boundary-3plm</guid>
      <description>&lt;h1&gt;
  
  
  Your AI Workflow Needs an Idempotency Boundary
&lt;/h1&gt;

&lt;p&gt;Tool-using agents make retries feel natural. The model sees an ambiguous tool result and tries again. That is reasonable for a search query and dangerous for a payment, account creation, or irreversible change.&lt;/p&gt;

&lt;p&gt;A retry after timeout cannot tell whether the first attempt was committed. The correct boundary lives in the tool service, not in a prompt telling the model to be careful.&lt;/p&gt;

&lt;p&gt;For commands with side effects, the caller supplies a stable operation ID. The tool validates the command, claims that ID atomically, and returns the stored outcome on repeat requests. The agent can retry the exact same operation without performing it twice. A changed request body with the same ID must fail explicitly.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Agent --&amp;gt; tool call + operation ID
                   |
             atomic lookup
               /      \
            new      existing
             |          |
           execute   return result
             |
         persist result
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;There is another subtlety: the agent may generate a different operation ID on each retry. The orchestration layer should assign the identity for a logical business action and reuse it across tool attempts. Otherwise every retry is unique by construction.&lt;/p&gt;

&lt;p&gt;Idempotency is not an AI-specific pattern. What changed is that model-driven workflows make repeated and uncertain calls much more common. The old distributed-systems rules still apply.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>distributed</category>
    </item>
    <item>
      <title>Design AI Systems Around Failure, Not the Demo</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Thu, 12 Feb 2026 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/design-ai-systems-around-failure-not-the-demo-4gdi</link>
      <guid>https://dev.to/alexgeorghiou/design-ai-systems-around-failure-not-the-demo-4gdi</guid>
      <description>&lt;h1&gt;
  
  
  Design AI Systems Around Failure, Not the Demo
&lt;/h1&gt;

&lt;p&gt;The prototype runs once, the answer looks impressive, and everyone wants it in production. That is where the real design work begins.&lt;/p&gt;

&lt;p&gt;What happens if retrieval returns no evidence? If a tool times out after creating a record? If the model proposes an action outside its permissions? If the user asks the same question twice and the agent repeats a non-idempotent operation?&lt;/p&gt;

&lt;p&gt;I design for these cases before expanding autonomy. Every tool needs an explicit contract with inputs, validation, timeouts, and an idempotency strategy where relevant. Every workflow needs a way to stop, resume, and explain its current state. Human review needs to be a deliberate branch, not an emergency patch.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Request -&amp;gt; Plan -&amp;gt; Bounded tool call -&amp;gt; Validate result
              ^                            |
              |                         success?
              +---- retry or revise &amp;lt;--- no
                                           |
                                          yes
                                           v
                                      Commit / review
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Observability should capture steps and decisions without indiscriminately retaining sensitive prompts. Trace the request across retrieval, model calls, tool execution, and policy checks. Measure failures by stage, not just whether the final response exists.&lt;/p&gt;

&lt;p&gt;The question for production readiness is not "Can it complete the happy path?" It is "Can we explain, contain, and recover from the unhappy paths?"&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>agents</category>
    </item>
    <item>
      <title>The Context Window Is Not a Memory Strategy</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Thu, 16 Oct 2025 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/the-context-window-is-not-a-memory-strategy-538l</link>
      <guid>https://dev.to/alexgeorghiou/the-context-window-is-not-a-memory-strategy-538l</guid>
      <description>&lt;h1&gt;
  
  
  The Context Window Is Not a Memory Strategy
&lt;/h1&gt;

&lt;p&gt;When an agent forgets something important, the first instinct is often to give it more context. A longer context window can help, but it is not a substitute for a memory design.&lt;/p&gt;

&lt;p&gt;Different information has different lifetimes. The current user's request belongs in working context. A verified account preference may belong in a durable store. A retrieved reference document should be fetched when relevant. An old tool trace usually belongs in neither place.&lt;/p&gt;

&lt;p&gt;Stuffing all of these into every prompt increases cost and can reduce clarity. It also makes security harder: a stale document may override fresh policy, or a previous user's data may leak through an incorrectly scoped summary.&lt;/p&gt;

&lt;p&gt;I model memory as explicitly managed state with source, timestamp, owner, scope, and deletion behavior. Updates must be deliberate. A model should not silently turn an unverified statement from a retrieved page into a permanent fact about a user.&lt;/p&gt;

&lt;p&gt;When context is compacted, preserve decisions and open questions, not every sentence. When information can be re-retrieved reliably, store a reference instead of an enormous copy.&lt;/p&gt;

&lt;p&gt;A context window is a transport for relevant information at inference time. Memory is a product and data-governance decision. Confusing them creates systems that are expensive and difficult to trust.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
    </item>
    <item>
      <title>An LLM Evaluation Set Is a Living Contract</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Tue, 08 Jul 2025 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/an-llm-evaluation-set-is-a-living-contract-14eg</link>
      <guid>https://dev.to/alexgeorghiou/an-llm-evaluation-set-is-a-living-contract-14eg</guid>
      <description>&lt;h1&gt;
  
  
  An LLM Evaluation Set Is a Living Contract
&lt;/h1&gt;

&lt;p&gt;"The answers look better" is not an evaluation strategy. When a prompt, model, retriever, or tool changes, you need a way to tell whether the system improved in the cases that matter.&lt;/p&gt;

&lt;p&gt;I start with a small, curated dataset of representative tasks. Each example contains the input, relevant evidence, expected constraints, and a way to judge success. For factual answers, citation quality and unsupported claims matter. For tool-using workflows, correct action choice and permission compliance matter even more.&lt;/p&gt;

&lt;p&gt;Include uncomfortable examples: incomplete documents, contradictory sources, stale records, ambiguous names, and hostile text hidden inside retrieved material. The easiest examples are the least useful for finding regressions.&lt;/p&gt;

&lt;p&gt;Automated graders help but should not be treated as infallible. Use deterministic assertions where possible, sampled human reviews for nuanced cases, and separate metrics for safety, correctness, latency, and cost. A change that improves answer fluency while doubling unsafe tool calls is not an improvement.&lt;/p&gt;

&lt;p&gt;Version your evaluation data and keep the reasons for expected outcomes. When production reveals a new failure, add a sanitized regression case. That is how the evaluation suite becomes an engineering asset instead of a one-off demo.&lt;/p&gt;

&lt;p&gt;The goal is not a perfect score. It is the ability to make a change and know what you broke.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>testing</category>
      <category>architecture</category>
    </item>
    <item>
      <title>Stop Using Agents for Deterministic Workflows</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Thu, 17 Apr 2025 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/stop-using-agents-for-deterministic-workflows-2p45</link>
      <guid>https://dev.to/alexgeorghiou/stop-using-agents-for-deterministic-workflows-2p45</guid>
      <description>&lt;h1&gt;
  
  
  Stop Using Agents for Deterministic Workflows
&lt;/h1&gt;

&lt;p&gt;Not every workflow becomes better when an agent is allowed to choose the next step.&lt;/p&gt;

&lt;p&gt;If the process is always validate input, check account status, calculate a fee, and update a record, ordinary code provides stronger guarantees at lower cost. A model introduces latency, variability, token costs, and new failure modes while adding little value.&lt;/p&gt;

&lt;p&gt;Agents become interesting when the path depends on interpretation or exploration: gathering evidence from inconsistent documents, comparing possible explanations, or determining which questions remain unanswered. Even there, the agent should operate inside a bounded set of permissions and outcomes.&lt;/p&gt;

&lt;p&gt;A hybrid workflow is often the better architecture. Use deterministic routing for known steps, a model for genuinely ambiguous decisions, and explicit validation at the transition back into system state.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Input -&amp;gt; Validation -&amp;gt; Fixed business rules
                         |
                 ambiguous evidence?
                    /         \
                  no          yes
                  |            |
                commit     Agent analysis
                               |
                         validate -&amp;gt; review
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The engineering test is straightforward: list the decisions that require judgment. If you cannot name them, you probably do not need an agent. If you can name them, specify what evidence the agent may inspect and which actions remain forbidden.&lt;/p&gt;

&lt;p&gt;Good automation removes uncertainty where it can. It does not manufacture uncertainty for the sake of using AI.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>agents</category>
    </item>
    <item>
      <title>The Agent Should Not Approve Its Own Work</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Wed, 29 Jan 2025 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/the-agent-should-not-approve-its-own-work-45j2</link>
      <guid>https://dev.to/alexgeorghiou/the-agent-should-not-approve-its-own-work-45j2</guid>
      <description>&lt;h1&gt;
  
  
  The Agent Should Not Approve Its Own Work
&lt;/h1&gt;

&lt;p&gt;An AI agent that can propose a financial adjustment and approve it has collapsed a separation-of-duties control into one probabilistic component.&lt;/p&gt;

&lt;p&gt;The usual argument is convenience: the model can inspect documents, reason about them, call tools, and finish the workflow. That is attractive for low-risk operations. For irreversible or high-impact actions, the same autonomy becomes an unacceptable concentration of authority.&lt;/p&gt;

&lt;p&gt;I separate proposing from committing. The agent can gather evidence, explain its recommendation, and prepare a structured change. A deterministic policy engine validates limits, identity, and allowed transitions. Some changes also require a human approver.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Documents --&amp;gt; Agent proposal --&amp;gt; Policy checks
                                     |
                              low risk / high risk
                                 |         |
                              execute    review
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This pattern is not about distrusting every model output. It is about making guarantees at the layer capable of enforcing them. A language model can explain why a threshold should be raised; it should not be the sole mechanism enforcing that threshold.&lt;/p&gt;

&lt;p&gt;The workflow also needs a durable audit trail: evidence used, model and prompt version, proposed action, policy result, reviewer, and final outcome. A verbose conversation transcript is not a substitute for structured decisions.&lt;/p&gt;

&lt;p&gt;Give agents room to reason. Keep authority explicit.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
    </item>
    <item>
      <title>Prompt Injection Is a Trust Boundary Bug</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Tue, 10 Sep 2024 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/prompt-injection-is-a-trust-boundary-bug-3phf</link>
      <guid>https://dev.to/alexgeorghiou/prompt-injection-is-a-trust-boundary-bug-3phf</guid>
      <description>&lt;h1&gt;
  
  
  Prompt Injection Is a Trust Boundary Bug
&lt;/h1&gt;

&lt;p&gt;A prompt injection is not just a badly worded question. It is an attempt to make lower-trust content override instructions or permissions that belong to a higher-trust layer.&lt;/p&gt;

&lt;p&gt;The attacker may control a web page, a document, a ticket comment, or a tool result. The assistant reads it as data. The attack asks the assistant to treat that data as a command: reveal secrets, ignore policy, or call an unrelated tool.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Trusted policy -----------+
                          v
User request --------&amp;gt; decision layer --&amp;gt; allowed action
                          ^
Untrusted document --------+ (data only)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The essential defense is architectural. Restrict tool permissions, validate tool arguments, keep secrets away from the model where possible, and require deterministic checks before sensitive actions. Marking content as untrusted helps, but text labels alone are not a security boundary.&lt;/p&gt;

&lt;p&gt;Test with malicious examples planted in retrieved passages. Ask whether the system follows instructions in the passage or merely uses its factual content. Keep an audit trail of proposed and executed actions so an incident can be reconstructed.&lt;/p&gt;

&lt;p&gt;A prompt is a useful interface. It is not a replacement for authorization, transaction controls, or sandboxing.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>architecture</category>
    </item>
    <item>
      <title>A Vector Database Is Not a Permission System</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Tue, 21 May 2024 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/a-vector-database-is-not-a-permission-system-ehp</link>
      <guid>https://dev.to/alexgeorghiou/a-vector-database-is-not-a-permission-system-ehp</guid>
      <description>&lt;h1&gt;
  
  
  A Vector Database Is Not a Permission System
&lt;/h1&gt;

&lt;p&gt;Semantic search makes it easy to retrieve information that looks relevant. It can also make it easy to retrieve information the caller should never see.&lt;/p&gt;

&lt;p&gt;The security boundary must not depend on the model deciding whether a passage is confidential. Authorization belongs before retrieval and, when appropriate, in a verified post-filter applied before the model receives context.&lt;/p&gt;

&lt;p&gt;Multi-tenant search needs especially careful design. If one shared index holds many customers' documents, tenant scoping must be enforced as a non-optional condition. A prompt saying "only answer for the current tenant" is not an isolation mechanism.&lt;/p&gt;

&lt;p&gt;Identifiers matter here. Every chunk should retain a reliable document ID, tenant boundary, access policy reference, and version. When permissions change or a document is deleted, ask how the index reflects it. An out-of-date embedding can become a long-lived data exposure.&lt;/p&gt;

&lt;p&gt;I also separate tool permissions from answer permissions. A user allowed to read a support article is not necessarily allowed to trigger the administrative action described in it.&lt;/p&gt;

&lt;p&gt;Treat retrieved text as untrusted input. It may contain instructions aimed at the assistant. The model may summarize it, but the text must not acquire authority simply by appearing in context.&lt;/p&gt;

&lt;p&gt;Similarity is about relevance. Authorization is about entitlement. One cannot substitute for the other.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>architecture</category>
    </item>
    <item>
      <title>RAG Fails Quietly When Retrieval Looks Plausible</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Tue, 06 Feb 2024 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/rag-fails-quietly-when-retrieval-looks-plausible-43f9</link>
      <guid>https://dev.to/alexgeorghiou/rag-fails-quietly-when-retrieval-looks-plausible-43f9</guid>
      <description>&lt;h1&gt;
  
  
  RAG Fails Quietly When Retrieval Looks Plausible
&lt;/h1&gt;

&lt;p&gt;A language model can produce a confident answer from a perfectly irrelevant document. That is why a retrieval system must be evaluated independently from the text it generates.&lt;/p&gt;

&lt;p&gt;A common mistake is to test only whether the final response sounds reasonable. In a retrieval-augmented system, inspect what the retriever found: does the relevant passage appear in the top results, is it current, does it apply to the right customer or document version, and is access control enforced before any context reaches the model?&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Question
   |
   v
Authorization --&amp;gt; retrieval --&amp;gt; reranking
                           |
                           v
                       evidence
                           |
                           v
                     answer + citations
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Chunking affects recall. Tiny chunks lose context. Huge chunks dilute the signal and waste context space. Metadata filtering can improve precision, but only if metadata is maintained correctly. And a vector score alone is not proof of correctness.&lt;/p&gt;

&lt;p&gt;Build an evaluation set with real questions, expected evidence, and deliberately tricky negatives. Track retrieval recall separately from answer faithfulness. If the right evidence is missing, changing prompts will not fix the underlying retrieval problem.&lt;/p&gt;

&lt;p&gt;The most useful question in a RAG review is not "Which model are we using?" It is "Show me a case where retrieval was wrong and how we detected it."&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>rag</category>
    </item>
    <item>
      <title>The Audit Log Is Not Your Debug Log</title>
      <dc:creator>Alex Georghiou</dc:creator>
      <pubDate>Tue, 15 Aug 2023 10:00:00 +0000</pubDate>
      <link>https://dev.to/alexgeorghiou/the-audit-log-is-not-your-debug-log-45k2</link>
      <guid>https://dev.to/alexgeorghiou/the-audit-log-is-not-your-debug-log-45k2</guid>
      <description>&lt;h1&gt;
  
  
  The Audit Log Is Not Your Debug Log
&lt;/h1&gt;

&lt;p&gt;Debug logs answer "What happened inside the process?" Audit records answer "Who did what, to which resource, under what authority, and with what outcome?" They are related but not interchangeable.&lt;/p&gt;

&lt;p&gt;A debug log might contain exception details, timings, and transient values. It may be rotated after days. An audit record needs stable identifiers, a deliberate retention policy, access control, and enough information to reconstruct meaningful actions months later.&lt;/p&gt;

&lt;p&gt;I prefer audit events at business boundaries: permission granted, limit changed, document approved, record exported. The event should capture an actor identity, action, target, timestamp, request or correlation identifier, and relevant before/after context without copying sensitive data indiscriminately.&lt;/p&gt;

&lt;p&gt;Do not assume a row in a mutable database table is tamper-evident. Depending on the requirements, append-only storage, restricted write permissions, integrity checks, and independent retention may matter.&lt;/p&gt;

&lt;p&gt;Audit logging can also fail. Decide whether a critical action must be blocked if its audit entry cannot be durably recorded. There is no universal answer. A routine read and a privileged security change have different consequences.&lt;/p&gt;

&lt;p&gt;Treat auditability as an explicit requirement during design. Retrofitting it from random application logs is usually too late.&lt;/p&gt;

</description>
      <category>security</category>
      <category>architecture</category>
      <category>backend</category>
    </item>
  </channel>
</rss>
