<?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 Unwana Uforo Okoro-Nwanja on Medium]]></title>
        <description><![CDATA[Stories by Unwana Uforo Okoro-Nwanja on Medium]]></description>
        <link>https://medium.com/@unwanauforo?source=rss-c14f614f0bec------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Unwana Uforo Okoro-Nwanja on Medium</title>
            <link>https://medium.com/@unwanauforo?source=rss-c14f614f0bec------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:46:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@unwanauforo/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[Caching in the Age of AI:]]></title>
            <link>https://medium.com/@unwanauforo/caching-in-the-age-of-ai-fa821d33cf00?source=rss-c14f614f0bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa821d33cf00</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[cache]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Unwana Uforo Okoro-Nwanja]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 21:51:49 GMT</pubDate>
            <atom:updated>2026-10-15T21:51:49.347Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Speed Without Sacrificing Data Integrity</strong></p><p>When Software Engineers think about performance optimization, caching is usually one of the first techniques that comes to mind. Properly implemented, it can significantly reduce response times, decrease database load, and improve scalability.</p><p>However, caching comes with an important caveat:</p><blockquote><strong>A cache faithfully stores whatever you give it — good or bad.</strong></blockquote><p>Today, AI coding assistants can generate caching implementations in seconds. Ask an AI tool to implement Redis caching in a .NET application, and it can produce code that retrieves data from a cache, queries the database on a cache miss, and stores the result for subsequent requests.</p><p>But generating code is only part of software engineering. The implementation must also account for how the application uses the data, how frequently that data changes, and what should happen when the underlying data is updated.</p><blockquote><strong>The real challenge is ensuring that the implementation is correct, reliable, and appropriate for the system it serves.</strong></blockquote><p>Consider what happens when an application caches outdated data or fails to invalidate an entry after an update. The application may continue serving incorrect results, potentially at an even greater scale because those results are now delivered faster and more frequently.</p><p>These are not problems that disappear simply because the code was generated by AI. They require engineers to understand the system’s requirements, anticipate failure scenarios, and make deliberate decisions about data consistency and cache invalidation.</p><p>This raises an important question:</p><p><strong>In an era where AI can write the code, how do we ensure that the code does what the business actually needs?</strong></p><p>Let’s explore caching, the common pitfalls engineers encounter, and the decisions that matter when building reliable systems.</p><h3>What is Caching?</h3><p>Caching is the process of storing accessed data in a faster storage layer so future requests can be served without repeatedly querying the original data source, i.e. instead of the application always connecting to a database or calling an API.</p><p>Instead of querying a database or calling an external API every time a request arrives, an application can retrieve previously stored results from a cache.<br>The result is:<br>. <em>Faster response times</em>: Data can be retrieved from a cache more quickly from a database or remote service<br>· <em>Reduced database load</em>: Fewer repeated queries mean less work for the underlying sources<br>. <em>Better scalability:</em> The application can handle more requests without increasing database capacity proportionally<br>. <em>Lower infrastructure costs</em>: Reduced database and external API usage can translate into lower operational cost</p><h3>Why Use Caching?</h3><p>Imagine an endpoint that receives 20,000 requests every minute.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*mUWiMP3mnpuzQvNe8FzfGA.png" /><figcaption>Fig 1.0 Caching instead of memory</figcaption></figure><p>That’s a significant reduction in database traffic.</p><h3>Choosing the right cache</h3><p>There are different types of Cache, and it’s essential to use the cache that is fit for purpose. Caching properly ensures easy storage and retrieval of data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ecnZ2szZC6GDQAtM89L8Ug.png" /><figcaption>Fig 1.1 Cache and the explanation</figcaption></figure><h3>Common Pitfalls using a cache</h3><p>Caching, though efficient, introduces new challenges. Understanding these challenges is essential when designing reliable applications.</p><p><strong>a. Dirty Data:</strong><br>One of the most overlooked problems is caching data that is already incorrect. Developers mostly trust that the data source would always return the correct data and do not validate before inserting into the cache.<br>If corrupted or invalid data is written into the cache, the cache will consistently return incorrect results until it’s invalidated or cleared.</p><blockquote><strong>Solution:</strong><br>Validate data before adding to the cache. This is why validation matters.<br>A cache is not responsible for ensuring correctness — it simply accelerates access.</blockquote><p><strong>b. Stale Data:</strong><br>The cache isn’t refreshed after the datasource changes. It occurs when the cache contains an older version of a record than the version currently held by the datasource. i.e. Consider a customer whose account status changes from <em>Active </em>to <em>Suspended</em>, but imagine the application continues returning the cache <em>Active </em>status, which might make decisions based on outdated information.<br><strong>Solution:</strong><br>o Clear/update the cache after every database update, so the next request fetches fresh data.<br>o Set a cache expiry (Time-To-live — TTL), e.g. 10 minutes, so stale data is automatically removed.<br>o Provide a manual refresh option for administrators if needed.<br>o Read directly from the datasource source when freshness is critical.</p><p><strong>c. Cache Stampede: </strong><br>Many requests hit an expired/missing cache simultaneously. This can cause a surge at the datasource, instead of reducing traffic at the datasource.<br><strong>Solution:</strong><br>o <em>Locking</em>: Allow only one request to refresh the cache while others wait.<br>o <em>Request Coalescing</em>: Combine multiple requests into one request to fetch the data.<br>o <em>Refresh Ahead</em>: Refresh the cache before it expires so requests always have fresh data.</p><p><strong>d. Cache Avalanche: </strong><br>Thousands of keys expire/become available within a short period or at the same time, causing many datasources calls to hit simultaneously. Unlike cache stampede which commonly centres on a single key or a small number of hot keys, it can affect many keys simultaneously.<br><strong>Solution:</strong><br>o <em>Randomize expiration times</em>. This spreads the database load over time</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*CTAc4t_V7noAbqrxbooHng.png" /><figcaption>Fig 1.2 Cache Avalanche</figcaption></figure><p><strong>e. Cache Penetration: </strong><br>This Occurs when users repeatedly ask for data that doesn’t exist in the underlying datasource. Because the record is never found, the application does not populate the cache with a normal result, so results keep reaching the database.<br><strong>Solution:</strong><br>a) <em>Cache null/negative values</em>: Cache the record not found for maybe 1–5 minutes. Word of caution, failures should not be cached as though the record does not exist.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/1*HvR3iyC491U7tW5vQQF6pg.png" /><figcaption>Fig 1.3 Cache Avalanche</figcaption></figure><p>b) <em>Validate input:</em> Quickly check if the key could exist before allowing the request to reach the database. i.e. check the account number format or length of the account number est.</p><h3>Best Practices for reliable caching</h3><p>Regardless of whether the code is written manually or generated by AI, the following principles remain important</p><p>✔ Validate critical data before caching. Ensure the data is correct before storing in cache.<br>✔ Define clear expiration policies. The cache entry cannot live forever. Make it realistic and set how long each entry should remain before it expires.<br>✔ Design cache invalidation strategies: Defines how cached data should be removed or refreshed when the data changes<br>✔ Monitor cache hit ratios.<br>✔ Monitor cache size.<br>✔ Keep cache entries small. Expire when necessary<br>✔ Never treat cache entries as the source of truth.<br>✔ Understand consistency requirements before choosing a caching strategy</p><p><strong>Final Thoughts</strong><br>Caching is one of the most effective ways to improve application performance, but it should never come at the expense of data integrity.</p><p>AI has made implementing common caching patterns faster and more accessible. It can generate code, suggest optimizations, identify potential defects, and help engineers investigate performance problems.</p><p>But implementation is only one part of the engineering process.</p><p>A caching solution must still be evaluated against the system’s requirements, data consistency expectations, security constraints, and failure scenarios.<br>A well-designed cache reduces latency, improves scalability, and lowers infrastructure costs. A poorly managed cache can amplify stale or invalid data across your system.<br>The goal isn’t simply to make your application faster, it’s to make it faster <strong>without compromising correctness.</strong></p><blockquote><strong>A cache doesn’t improve data quality. It improves data delivery. Make sure you deliver the right data.</strong></blockquote><p>In part two, we would discuss how to work with the AI Coding assistants to determine the appropriate caching strategy and validation of caching implementations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa821d33cf00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Under looked aspect of API Calls — The HTTP Version 1.0, 1.1 or 2]]></title>
            <link>https://medium.com/@unwanauforo/under-looked-aspect-of-api-calls-the-http-version-1-0-1-1-or-2-e5dbf5d85576?source=rss-c14f614f0bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5dbf5d85576</guid>
            <dc:creator><![CDATA[Unwana Uforo Okoro-Nwanja]]></dc:creator>
            <pubDate>Sat, 04 Jul 2026 16:06:15 GMT</pubDate>
            <atom:updated>2026-07-04T16:06:15.431Z</atom:updated>
            <content:encoded><![CDATA[<p>How do you diagnose a situation where a .NET Core application intermittently receives <strong>HTTP 404 (Not Found)</strong> responses from an API, yet the exact same endpoint works consistently from a PHP application and even Postman?</p><p>The strange part? The failed requests far outnumbered the successful ones.</p><p>Now, a <strong>404 error</strong> usually means the requested resource doesn’t exist. But in this case, we already knew the endpoint was valid. Other applications were calling it successfully, so why was the .NET Core application getting “Not Found”?</p><p>Honestly, this is the kind of issue does not make sense at first glance — it feels like frustration wrapped in a box and delivered straight to your desk.</p><p>After deep-dive troubleshooting and comparing the raw Http requests being sent from Postman, the PHP application, and the .NET Core application), we discovered an unexpected culprit:</p><p><strong><em>The HTTP version used for the API call.</em></strong></p><p><em>The PHP application was sending requests using </em><strong><em>HTTP/1.1</em></strong><em> by default.</em></p><p><em>The .NET Core application was initiating protocol negotiation resulting in </em><strong><em>HTTP/2.0</em></strong></p><p><strong><em>Wait… the HTTP version can cause 404 Errors?</em></strong></p><p><strong><em>Yes. absolutely. The HTTP version!</em></strong></p><p><strong><em>Why does the HTTP Version Matter?</em></strong></p><p>For most API Integrations, Developers focus on URLs, http methods (get or post), payloads, authentication, requests, responses est. Why should we bother with http versions?</p><p>HTTP versions define how communication happens between the client and server. <strong>Simply, how they move the data. </strong>It represents the set of underlying rules that define exactly how data is requested and transferred between web clients and servers.</p><p><strong>HTTP/1.1: Sequential Delivery. </strong>The server must send one complete file before it can start sending the next.</p><figure><img alt="Fig 1.0 Diagrammatical representation of Http 1.0, 1.1" src="https://cdn-images-1.medium.com/max/1024/1*vo-0EuAJSGUSOA-8A4tIzw.png" /><figcaption>Fig 1.1 Diagrammatical Representation of Http1.1 calls</figcaption></figure><p><strong>HTTP/2 &amp; HTTP/3: Multiplexed Delivery</strong> The server chops all the requested files into tiny, distinct pieces (frames) and streams them all simultaneously over a single, highly efficient connection. The browser instantly reassembles them on arrival.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RCLDdM4x9I37hHUFKYZNCw.png" /><figcaption>Fig 1.2 Diagrammatical Representation of Http 2/3 calls</figcaption></figure><p>When establishing a connection, the HTTP version negotiated between the client and server can affect how that connection is routed and processed. Modern .NET HttpClient implementations often attempt to negotiate HTTP/2 by default, whereas older applications or specific tools (like Postman) might default to HTTP/1.1.</p><p><strong><em>The Missing Link: How Servers Handle the Handshake</em></strong></p><p>But why did the protocol mismatch result in a 404 “Not Found” error instead of just dropping the connection or throwing a standard connection error?</p><p>This comes down to infrastructure limitations. When your API call leaves the client, it usually hits a reverse proxy or API gateway before reaching the application code. In our case, the destination endpoint was hosted on a NGINX server and was explicitly configured to use HTTP/1.1.</p><p>But here is the catch: not all web servers enforce these rules the same way. To understand why our .NET application was quietly handed a 404 while the PHP app sailed right through, we must look at the massive difference between how Windows and NGINX handle protocol mismatches. his is where the difference between environments like Windows (IIS/HTTP.sys) and Linux (Nginx) becomes a massive debugging factor.</p><p><strong><em>Windows vs Nginx: The invisible Routing Game</em></strong></p><p><strong>Windows (IIS) Approach:</strong> Windows servers are built to accommodate. If an IIS server receives an HTTP/2 request but doesn’t fully support it (or the backend doesn’t), Windows will usually quietly switch the connection back to the older HTTP/1.1 so things keep working without interrupting you. If that backup plan completely fails, it throws a loud, clear error (like a 502 Bad Gateway or a 400 bad request). This makes it obvious to developers that the communication line itself is broken.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_w6HEoCDUudL04hSTsy9pw.jpeg" /><figcaption>Fig 1.3 Diagrammatical illustration of Windows handling HTTP Versions</figcaption></figure><ul><li><strong>The Nginx Approach:</strong> Nginx acts like a highly strict, explicit bouncer at a club. The bouncer has a very specific rulebook for every single room inside. If someone walks up trying to use a brand-new VIP pass (HTTP/2), but the bouncer’s clipboard doesn’t <em>explicitly</em> say that specific room accepts VIP passes — or if they can’t agree on the security handshake at the door — the bouncer won’t try to help them figure it out. They just reject the connection</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KDbluVgfuV-3oZ7L8N7ITA.jpeg" /><figcaption>Fig 1.4 Diagrammatical illustration of NGINX Server handling HTTP Versions</figcaption></figure><p><strong>So, why the 404?</strong> In many Nginx or Linux-based API Gateway configurations, if a request’s protocol negotiation fails on the intended route, Nginx doesn’t necessarily drop the connection. Instead, it fails to match the specific application route and falls back to a <strong>default “catch-all” server block</strong>(<strong>bin</strong>)</p><p>What does a default catch-all block usually do? It returns a <strong>404 Not Found</strong>.</p><p>The gateway essentially said: “I see you are speaking HTTP/2, but I don’t have an HTTP/2 route mapped for this URL. Therefore, this resource doesn’t exist.” The PHP app used HTTP/1.1, which matched the gateway’s expected routing rules perfectly, bypassing the bouncer. The modern .NET application enthusiastically announced itself with HTTP/2, failed the gateway’s routing logic, and was quietly handed a 404.</p><p><strong><em>Solution</em></strong></p><p>The fix was to explicitly configure the .NET Core HttpClient to use HTTP/1.1 instead of relying on the default negotiation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*SXTEOqkTprcwqP3ugoPZXA.png" /><figcaption>Fig 1.5 Solution employed as a hotfix</figcaption></figure><p>This ensured the request matched what the API infrastructure expected.</p><p><strong><em>Key Lessons</em></strong></p><p><strong>Compare the complete request: </strong>Always compare the complete HTTP request when troubleshooting API issues.Not just URL, headers, and payload.</p><p><strong>Clients behave differently: </strong>Postman, PHP, Java, and .NET may send technically different requests, under the hood even when calling the same endpoint.</p><p><strong>HTTP version is an API dependency: </strong>It is not just a performance setting.</p><p><strong>Infrastructure matters:</strong> Windows-based hosting environments and Nginx-based environments may handle API traffic differently, especially protocol negotiation.</p><p><strong>Read the documentation: </strong>Request detailed documentation on all aspects of the Api integration to avoid client issues.</p><p><strong><em>Final Thoughts</em></strong></p><p>One of the biggest lessons from this incident: When an API works from one client but fails from another, don’t immediately assume the code is wrong. The fastest way to debug is to look at the differences in how <em>clients</em> process the request.</p><p>Sometimes the difference is hidden in the things we rarely look at:</p><ul><li>HTTP Version</li><li>TLS negotiation</li><li>Connection handling</li><li>Proxy behavior</li><li>Compression</li><li>Headers</li></ul><p>The smallest difference in a request can create the biggest debugging headache.</p><p>For more details, you read more at</p><ul><li><a href="https://dev.to/paraspanchal/understanding-http-versions-a-comprehensive-guide-16n9">Understanding HTTP Versions (Dev.to)</a></li><li><a href="https://en.wikipedia.org/wiki/HTTP">HTTP Wikipedia</a></li><li><a href="https://www.cyberdefensemagazine.com/http-1-1-vs-http-2-what-are-the-differences/?__cf_chl_f_tk=k7A9puKGLvo1BqD885dOvbCcwC9gVqCea33odf5WmZc-1783175796-1.0.1.1-sqKYYQJZsO3ulv3.79OHmdOGoA4fESxTcPWKfuyI87U">HTTP/1.1 vs HTTP/2: What are the differences? (Cyber Defense Magazine)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5dbf5d85576" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Resolving Missing Cache Values in Memory Cache: A Hard learned lesson]]></title>
            <link>https://medium.com/@unwanauforo/resolving-missing-cache-values-in-memory-cache-ef496049fd16?source=rss-c14f614f0bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef496049fd16</guid>
            <category><![CDATA[in-memory-cache]]></category>
            <category><![CDATA[isis]]></category>
            <category><![CDATA[redis]]></category>
            <category><![CDATA[observability]]></category>
            <dc:creator><![CDATA[Unwana Uforo Okoro-Nwanja]]></dc:creator>
            <pubDate>Wed, 18 Jun 2025 22:48:58 GMT</pubDate>
            <atom:updated>2025-06-18T22:48:58.972Z</atom:updated>
            <content:encoded><![CDATA[<p>Have you ever spent more than a day troubleshooting a persistent issue, only to discover the solution was surprisingly simple? Join me as I recount a similar experience in a recently completed project where we struggled with intermittent failures on a webservice. What started as performance optimization ended up impacting session consistency due to a misconfiguration in IIS.</p><h3>The web service flow</h3><ul><li>The web service generates a session Id (e.g., “ABC123”).</li><li>Web service stores the session Id in the default memory cache.</li><li>Subsequent operations, i.e., balance inquiry relied on retrieving the session ID from the cache to complete the operation.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/821/1*lOQlGNDufjxrqrHmLOyjnw.png" /><figcaption>Diagrammatical representation of the Webservice’s operations</figcaption></figure><h4>The Problem — Epileptic customer experience</h4><p>Customers were having an epileptic experience, one moment they could conduct a balance inquiry, the next minute, it would fail. This unpredictability was disadvantageous to the project’s success, especially after a successful migration as all other customer-facing channels were functioning effectively and meeting customer needs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*rc2Jk_FaRzKJ1-1dGIzyzA.png" /><figcaption>Diagrammatic representation of the issue encountered</figcaption></figure><h3>Resolution Steps</h3><h4>Optimizing the Application</h4><p>· We initially suspected performance bottlenecks. One API had a response time exceeding 10 seconds. After optimization, we reduced this to 2 seconds, yielding only marginal improvements.</p><p>· Additional background servers and load balancing were introduced, which again provided slight performance gains.</p><p>· We refactored the code, optimized database calls, merged redundant requests, and removed unnecessary API calls. Despite these efforts, the core issue persisted.</p><h4>Improving observability</h4><p>We realized that our observability was lacking. Logging had been disabled in production to enhance performance, leaving us blind. After a day of flying blind and speculating about everything from hardware to the database to load balancing microservices, we had to face reality!</p><blockquote>Adding logs to the application was the most crucial task to moving ahead.</blockquote><p>We enhanced the logs to be more intuitive, focusing on the stack trace, which is invaluable for pinpointing the exact line where an error occurs. This improvement allowed us to identify a pattern.</p><blockquote><strong>This revealed that the session ID was intermittently missing from the in-memory cache at retrieval time, which directed our attention toward the underlying infrastructure.</strong></blockquote><h4>Identifying the root cause</h4><p>We systemically examined the IIS Application Pool Settings and discovered that the maximum worker process had been increased from 1 to 3 during performance tuning. This change effectively enabled a <strong>Web Garden</strong>, where multiple worker processes (w3wp.exe) handle requests independently.</p><blockquote><strong>Simple solution — Maximum Worker Process was changed back to 1.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*T8vM40pHxxBiGz4LIn7PhQ.png" /><figcaption>IIS App-Pool Settings</figcaption></figure><h4>How this affected the Web Service?</h4><p>In Simple terms, when IIS is set to use <strong>multiple worker processes</strong> (like 3), each of those processes runs <strong>separately</strong>, with <strong>its own memory</strong>. Think of them like three different kitchens — if you leave your session ID or cache data in one kitchen, and then go to another one, it will not be there.</p><p>So, when a user sends a request and it gets handled by <strong>Process A</strong>, the session ID gets stored in that process’s memory (cache). But on the next request, IIS might send the request to <strong>Process B</strong> or <strong>C</strong>, which has <strong>no knowledge of the session ID stored in Process A</strong> — leading to a “missing from cache” issue.</p><p>By reverting the <strong>Maximum Worker Process</strong> back to one, all requests go to the <strong>same process</strong>, like always using the <strong>same kitchen</strong>, so your session ID and cached data stay available and consistent between calls.</p><h4>Session Management in IIS</h4><p>Running a single worker process ensures that in-memory session state, cached data, and static variables are preserved across requests. Web Gardens, while beneficial in some stateless applications, introduce serious consistency challenges for applications relying on in-process storage.</p><h4>Summary/Recommendation</h4><p>We encouraged the Team to conduct the following in the long term:</p><p>· <strong>Implement Distributed Caching</strong>. For scalability and reliability, transition to a distributed cache like <strong>Redis</strong>. In-process memory cache does not scale well in multi-server or multi-process environments.</p><p>· <strong>Centralize Session Handling</strong>: Session handling should be centralized in a single class to follow clean design principles like separation of concerns and DRY to improve maintainability. It would have been easier to adopt a distributed cache like Redis when issues first appeared, avoided session issues, reduced troubleshooting time, and delivered a more stable user experience.</p><p>· <strong>Enhance Observability: </strong>Never compromise on logs in production. Detailed, structured logs are critical for diagnosing complex issues quickly<strong>.</strong></p><p>· <strong>Be Cautious with Load Testing Changes: </strong>Performance tuning should be accompanied by a thorough review of architecture and behavior under load. Configuration changes should be well-documented and revisited post-incident</p><h4>Conclusion</h4><p>This experience highlighted the importance of understanding infrastructure-level implications on application behavior. By revisiting fundamental configurations and reinforcing core engineering practices, we resolved a critical issue and improved the reliability of our web service. More importantly, the team emerged with valuable insights and a renewed commitment to observability, scalability, and robust design.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef496049fd16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Junior to Senior Software Developer (My Story)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@unwanauforo/from-junior-to-senior-software-developer-my-story-42229191ff72?source=rss-c14f614f0bec------2"><img src="https://cdn-images-1.medium.com/max/1873/1*usVHioAdt--lvnDCMeSX7g.png" width="1873"></a></p><p class="medium-feed-snippet">A training I recently attended had employees with various tech roles all in one room, all slated to attend the Agile Practices Training.</p><p class="medium-feed-link"><a href="https://medium.com/@unwanauforo/from-junior-to-senior-software-developer-my-story-42229191ff72?source=rss-c14f614f0bec------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@unwanauforo/from-junior-to-senior-software-developer-my-story-42229191ff72?source=rss-c14f614f0bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/42229191ff72</guid>
            <category><![CDATA[growth]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Unwana Uforo Okoro-Nwanja]]></dc:creator>
            <pubDate>Mon, 11 Jul 2022 18:28:29 GMT</pubDate>
            <atom:updated>2025-06-26T21:29:32.511Z</atom:updated>
        </item>
    </channel>
</rss>