<?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 Amith Jayasekara on Medium]]></title>
        <description><![CDATA[Stories by Amith Jayasekara on Medium]]></description>
        <link>https://medium.com/@amithdarshana?source=rss-ef7179d1f0a3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WZ19DTbgOABGaIKwVRoOdw.jpeg</url>
            <title>Stories by Amith Jayasekara on Medium</title>
            <link>https://medium.com/@amithdarshana?source=rss-ef7179d1f0a3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 06:05:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@amithdarshana/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[The Burj Khalifa of Code: Scaling Microservices with Vertical Thinking]]></title>
            <link>https://towardsaws.com/the-burj-khalifa-of-code-scaling-microservices-with-vertical-thinking-2afe5eeef1ff?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/2afe5eeef1ff</guid>
            <category><![CDATA[scaling]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Fri, 09 Jan 2026 04:16:13 GMT</pubDate>
            <atom:updated>2026-01-09T11:49:48.470Z</atom:updated>
            <content:encoded><![CDATA[<p>The Burj Khalifa, a marvel of modern engineering, faces a fascinating challenge: how do you move thousands of people efficiently through a structure over half a mile high? If everyone relied on a single elevator stopping at every floor, the wait times would be astronomical. Their solution isn’t just clever; it’s a profound lesson in scaling that we can directly apply to our software systems.</p><p>Welcome to the “Burj Khalifa of Code” — where we tackle the “elevator problem” in our microservices architecture to ensure our digital tenants (users) never get stuck waiting.</p><h3>The “Elevator Problem” in Software</h3><p>Imagine an early monolithic e-commerce application. Every user request — browsing products, adding to cart, checkout, payment — hits a single, massive application. As your user base grows, this single application becomes like that one elevator trying to serve 163 floors. It slows down, becomes unresponsive, and eventually, breaks. This is our software “elevator problem.”</p><p>Microservices promise a solution by breaking the monolith into smaller, independent services. But simply having many services isn’t enough. Without proper architectural “traffic control,” you can still end up with digital gridlock. This is where the Burj Khalifa’s design principles shine.</p><h3>Lesson 1: Express Shuttles to Sky Lobbies (API Gateway &amp; BFFs)</h3><p>In the Burj Khalifa, high-speed “express” elevators whisk you past dozens of floors to a “Sky Lobby” — an intermediate transfer point. From there, you take a local elevator to your specific floor. This prevents the main elevator shafts from getting clogged with local traffic.</p><p><strong>In an E-commerce Microservice Architecture:</strong></p><ol><li><strong>The Express Shuttle (API Gateway):</strong> All external user requests (from web browsers, mobile apps) first hit an <strong>API Gateway</strong>. This isn’t where business logic happens. Its job is to efficiently route requests to the correct set of backend services, perform basic authentication, and sometimes rate limiting. It’s the high-speed elevator getting you to the right “zone.</li><li><strong>The Sky Lobby (Backend for Frontend — BFF):</strong> Once through the API Gateway, requests land at a <strong>Backend for Frontend (BFF)</strong> layer. Just like a Sky Lobby is tailored to serve a specific section of the building (e.g., residential vs. corporate), a BFF is tailored to serve a specific client application (e.g., mobile-app-bff, web-admin-bff).</li></ol><ul><li>The mobile-app-bff knows exactly what data a mobile user needs for their product listing screen, aggregating calls to the Product Service, Review Service, and Price Service.</li><li>The web-admin-bff might expose different endpoints and data tailored for managing inventory.</li></ul><p>This prevents the mobile app from having to make multiple calls to individual microservices, drastically reducing latency and simplifying client-side code.</p><h3>Lesson 2: Dedicated Service Zones (Microservices &amp; Bulkheads)</h3><p>The Burj Khalifa has distinct zones: residential, corporate suites, observation decks. Each zone has its own set of local elevators and doesn’t interfere with the others. A power outage in the corporate section won’t strand residents.</p><p><strong>In an E-commerce Microservice Architecture:</strong></p><ol><li><strong>Dedicated Service Zones (Microservices):</strong> Each microservice is a dedicated &quot;zone&quot; handling a specific bounded context.</li><li><strong>Isolation (Bulkhead Pattern):</strong> If the Payment Service experiences a sudden surge in traffic or a bug, it shouldn&#39;t bring down the entire e-commerce platform. This is the <strong>Bulkhead Pattern</strong>. Each microservice runs in its own isolated environment (e.g., separate containers, separate databases, dedicated compute resources). A failure in one &quot;bulkhead&quot; doesn&#39;t cascade to others, ensuring the rest of the application remains operational. Users can still browse products even if payments are temporarily affected.</li></ol><h3>Lesson 3: Inter-floor Movement (Service Mesh)</h3><p>Sometimes, occupants need to move between floors within the same zone, or perhaps between adjacent zones. They don’t go all the way back to the ground floor.</p><p><strong>In an E-commerce Microservice Architecture:</strong></p><ol><li><strong>Service-to-Service Communication (East-West Traffic):</strong> Microservices frequently need to communicate with each other. For instance, when an order is placed, the Order Service needs to tell the Inventory Service to decrement stock and the Payment Service to process the charge. This is &quot;east-west traffic&quot; – internal service calls.</li><li><strong>Efficient Inter-Service Travel (Service Mesh):</strong> A <strong>Service Mesh</strong> (like Istio or Linkerd) acts as the intelligent internal elevator system. It provides:</li></ol><ul><li><strong>Traffic Management:</strong> Ensures calls between services are routed efficiently.</li><li><strong>Resilience:</strong> Automatically handles retries and circuit breaking if a downstream service is slow or unavailable.</li><li><strong>Security:</strong> Enforces mTLS (mutual Transport Layer Security) for all service-to-service communication.</li><li><strong>Observability:</strong> Provides rich metrics, logs, and traces for internal service calls, allowing you to see exactly where bottlenecks occur.</li></ul><p>This ensures that internal communication is fast, reliable, and secure, without adding complexity to the individual microservices.</p><h3>The “Staggered Start” (Asynchronous Processing with Message Queues)</h3><p>The Burj’s elevators handle peak demand by not allowing everyone to rush in at once. Similarly, in high-traffic software, we use <strong>asynchronous processing</strong> with <strong>message queues</strong> (e.g., Kafka, RabbitMQ).</p><ul><li>When a user clicks “Place Order,” the Order Service quickly creates the order and sends an &quot;Order Placed&quot; message to a queue. It doesn&#39;t wait for payment processing, inventory updates, and shipping notifications to all complete synchronously.</li><li>Other services (Payment Service, Inventory Service, Notification Service) consume these messages at their own pace, processing them independently. This dramatically improves responsiveness and throughput during peak loads, preventing any single service from becoming a bottleneck.</li></ul><h3>Conclusion: Building Resilient, Scalable Systems</h3><blockquote>The Burj Khalifa teaches us that scaling isn’t just about making things bigger; it’s about intelligent segmentation, dedicated pathways, and robust traffic management. By applying principles like API Gateways, BFFs, Bulkheads, Service Meshes, and Message Queues, we can engineer microservice architectures that stand tall, handle immense traffic, and provide a smooth experience for every user, no matter how high they need to go in our digital skyscraper.</blockquote><blockquote>So, the next time you design a distributed system, ask yourself: Am I building a single, overwhelmed elevator, or a meticulously planned Burj Khalifa of code?</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2afe5eeef1ff" width="1" height="1" alt=""><hr><p><a href="https://towardsaws.com/the-burj-khalifa-of-code-scaling-microservices-with-vertical-thinking-2afe5eeef1ff">The Burj Khalifa of Code: Scaling Microservices with Vertical Thinking</a> was originally published in <a href="https://towardsaws.com/">Towards AWS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boosting Software Performance: Layered Tactics for an Efficient Caching]]></title>
            <link>https://towardsaws.com/boosting-software-performance-layered-tactics-for-an-efficient-caching-25063568ebad?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/25063568ebad</guid>
            <category><![CDATA[layered-architecture]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[caching-strategies]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Tue, 09 Jan 2024 19:45:04 GMT</pubDate>
            <atom:updated>2024-01-10T03:39:12.075Z</atom:updated>
            <content:encoded><![CDATA[<p>In software architecture, layered architectures have proven to be a cornerstone for building scalable, modular, and maintainable systems. A well-thought-out caching strategy can make all the difference when aiming for optimal performance. In this article, we’ll explore the synergy between layered architecture and an effective caching strategy, starting at the domain level and extending, if needed, to other layers.</p><h3>Understanding Layered Architecture</h3><p>Layered architecture, often called n-tier architecture, structures a system into distinct layers, each with a specific role. Common layers include the presentation layer (UI), business layer (domain logic), and data layer (persistence). This separation fosters modularity, simplifies maintenance, and supports scalability.</p><h3>The Power of a Well-Crafted Caching Strategy</h3><p>Caching and storing frequently accessed or computationally expensive data is a game-changer in pursuing optimal performance. An effective caching strategy within the layered architecture enhances response times, reduces latency, and elevates the overall user experience.</p><h3>Starting at the Domain Level:</h3><h4>Pros:</h4><p><strong>Data Freshness:</strong></p><ul><li>Caching near the domain layer ensures that the cached data is close to the source of truth, minimizing the risk of serving stale or outdated information. This is crucial for maintaining data consistency.</li></ul><p><strong>Granular Control:</strong></p><ul><li>Domain services often handle specific types of data or operations. Caching at the domain level allows for precise control over what data is cached and how to optimize the cache for the unique needs of the domain.</li></ul><p><strong>Centralized Cache-Control:</strong></p><ul><li>Enjoy the benefits of centralized cache control. Defining cache expiration, eviction strategies, and other configurations can be done centrally, simplifying cache management.</li></ul><h4>Cons:</h4><p><strong>Resource Utilization:</strong></p><ul><li>Caching near the domain layer may increase resource utilization on the service itself. This impact on resource consumption should be considered and monitored.</li></ul><h3>Considering Other Layers:</h3><p>If the need for further optimization arises, extending the caching strategy to other layers becomes a logical step:</p><h4>Business Layer Caching:</h4><ul><li>Extend caching to the business layer if shared data or operations are across multiple domain services. This promotes reusability and reduces redundant computations.</li></ul><h4>Presentation Layer Caching:</h4><ul><li>Introduce caching at the presentation layer for scenarios where further round-trip reduction and improved user experience are necessary. This is particularly useful for minimizing network dependencies and enhancing UI responsiveness.</li></ul><h3>Conclusion: An Iterative Approach to Performance Optimization</h3><p>An effective caching strategy within a layered architecture is more than a one-size-fits-all solution. It requires an iterative and thoughtful approach. Starting at the domain level provides a strong foundation, addressing specific performance bottlenecks, and extending the strategy to other layers offers a balanced solution.</p><p>In the quest for optimal performance, architects and developers must analyze the unique characteristics of their applications, adapt the caching strategy to meet specific requirements and strike the right balance between resource utilization and responsiveness. By embracing the power of layered architecture and a well-crafted caching strategy, software systems can deliver a superior user experience while maintaining the integrity of the underlying data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25063568ebad" width="1" height="1" alt=""><hr><p><a href="https://towardsaws.com/boosting-software-performance-layered-tactics-for-an-efficient-caching-25063568ebad">Boosting Software Performance: Layered Tactics for an Efficient Caching</a> was originally published in <a href="https://towardsaws.com/">Towards AWS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cracking the Code Maze: A Beginner’s Guide to Succeeding in the World of Programming Languages]]></title>
            <link>https://towardsaws.com/cracking-the-code-maze-a-beginners-guide-to-succeeding-in-the-world-of-programming-languages-f3dcaa0117ae?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3dcaa0117ae</guid>
            <category><![CDATA[beginners-guide]]></category>
            <category><![CDATA[programing]]></category>
            <category><![CDATA[stayahead]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Sat, 16 Dec 2023 06:43:21 GMT</pubDate>
            <atom:updated>2023-12-18T05:26:38.567Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TwGGX_YfaJQgFm8b" /><figcaption>Photo by <a href="https://unsplash.com/@thisisengineering?utm_source=medium&amp;utm_medium=referral">ThisisEngineering RAEng</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The Art of Thoughtful Problem-Solving</h3><p>Much like an artist sketching the outlines of a masterpiece, programming begins with thoughtful problem-solving. Learning the basics — variables, control structures, and functions — is akin to creating the skeletal structure of your code, providing a foundation for your digital artwork.</p><p>For budding developers, envision the coding journey as an artist’s approach to a blank canvas. Each line of code is a brushstroke contributing to the overall picture. Cultivating a thoughtful approach to problem-solving is akin to guiding an artist through the initial stages, ensuring a solid foundation before immersing in the intricate details.</p><h3>Building Your Palette of Transferable Skills</h3><p>Once these basics are grasped, you’ve essentially assembled your tech palette. These skills are transferable across different languages, resembling a set of versatile brushes that seamlessly adapt to various coding canvases.</p><p>Imagine each programming language as a unique color on your palette. Understanding the basics allows developers to mix and match these colors, creating a rich tapestry of solutions. This versatility becomes the artist’s signature style, setting them apart in the ever-expanding world of technology.</p><h3>The Colors of Different Languages</h3><p>Programming languages, like colors, have specific purposes and unique attributes. Understanding the paradigms behind languages — whether procedural, object-oriented, or functional — is akin to appreciating the unique qualities of each color on your artistic palette. It empowers you to choose the right hues for your coding canvas.</p><p>Similar to how an artist selects colors to convey specific emotions, developers can choose a language based on its strengths for a given task. This decision-making process enhances the creative aspect of coding, transforming it from a technical exercise into an expressive endeavor.</p><h3>Painting the Future with Deliberate Agility</h3><p>Learning a new programming language becomes less daunting when approached with patience. It’s like adding brushstrokes to your canvas, with each stroke representing a new syntax or concept. The journey to acquiring new skills becomes an artistic adventure rather than a tedious climb.</p><p>Just as an artist refines their technique over time, a developer hones their skills with each new language they learn. The initial struggle to understand syntax and structure is akin to an artist’s early attempts to master brush techniques. With practice and persistence, the strokes become more confident and deliberate.</p><h3>Communicating in the Tower of Babel</h3><p>In collaborative tech environments, projects often resemble a Tower of Babel of languages. A basic understanding of programming facilitates effective communication and collaboration with team members speaking different coding dialects. It’s the universal language that keeps projects flowing seamlessly, much like artists collaborating on a mural.</p><p>Imagine a collaborative art project where each artist speaks a different language but shares a common understanding of artistic principles. This scenario parallels the collaborative coding process, where team members may have expertise in various languages but work together seamlessly to create a cohesive and functional project.</p><h3>Future-Proofing Your Code Canvas</h3><p>Tech careers are akin to evolving art exhibitions, with new styles and techniques emerging. Mastering programming basics provides a safety net for your code canvas. You become agile and adaptable, ready to experiment with new techniques and embrace emerging technologies. Continuous learning and curiosity become the brushes that add vibrancy to your ever-changing code artwork.</p><p>Consider a seasoned artist who stays relevant by experimenting with new mediums and styles. Similarly, a developer future-proofs their career by staying abreast of emerging technologies and trends. This adaptability ensures that their code remains relevant and innovative, much like an ever-evolving masterpiece in the world of technology.</p><h3>The Art of Patience: Don’t Rush, Plan</h3><p>In the coding artist’s toolkit, patience is a valuable brush. Resist the urge to rush into development; take your time, ponder, plan, and sketch the skeleton of your code before refining and improving it. This deliberate approach ensures a more thoughtful and robust creation.</p><p>Just as an artist contemplates the strokes before applying them to the canvas, a developer benefits from thoughtful planning. Take the time to think about the problem at hand, outline your plan, and sketch the skeleton of your code. This initial investment pays off in the form of a more organized and efficient development process.</p><h3>The Girl Scout Rule: Leave Code Cleaner Than You Found It</h3><p>As you embark on your coding journey, adopt the Girl Scout Rule — leave the code cleaner than you found it. Whether you’re crafting something new or touching up an existing masterpiece, this principle ensures that each brushstroke of code contributes to the overall elegance of the project.</p><p>Much like a conscientious artist who cleans their brushes between colors, a developer should clean the code with each iteration. This habit not only enhances readability but also sets a standard for maintaining a codebase that is efficient and easy to understand.</p><p>In conclusion, the journey to staying ahead of the tech curve isn’t just about mastering programming languages. It’s about embracing foundational principles, understanding language nuances, and adopting timeless rules like the Girl Scout Rule. So, grab your tech palette, embrace the diverse colors of languages, and enjoy the ever-changing canvas of the fascinating world of programming. Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3dcaa0117ae" width="1" height="1" alt=""><hr><p><a href="https://towardsaws.com/cracking-the-code-maze-a-beginners-guide-to-succeeding-in-the-world-of-programming-languages-f3dcaa0117ae">Cracking the Code Maze: A Beginner’s Guide to Succeeding in the World of Programming Languages</a> was originally published in <a href="https://towardsaws.com/">Towards AWS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Growing Strong: A Tale of Software Engineering and the Bamboo Tree]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://towardsaws.com/growing-strong-a-tale-of-software-engineering-and-the-bamboo-tree-cdade067943f?source=rss-ef7179d1f0a3------2"><img src="https://cdn-images-1.medium.com/max/1200/1*dBLuWGvIsc0Mjnce28DU3Q.jpeg" width="1200"></a></p><p class="medium-feed-snippet">In the vast world of software engineering, there&#x2019;s a story that holds a secret to success. It&#x2019;s about a tiny bamboo seed that dreams of&#x2026;</p><p class="medium-feed-link"><a href="https://towardsaws.com/growing-strong-a-tale-of-software-engineering-and-the-bamboo-tree-cdade067943f?source=rss-ef7179d1f0a3------2">Continue reading on Towards AWS »</a></p></div>]]></description>
            <link>https://towardsaws.com/growing-strong-a-tale-of-software-engineering-and-the-bamboo-tree-cdade067943f?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/cdade067943f</guid>
            <category><![CDATA[growth]]></category>
            <category><![CDATA[fresh-start]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[undergraduate]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Mon, 04 Dec 2023 12:56:04 GMT</pubDate>
            <atom:updated>2023-12-05T03:05:00.765Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Learning from the Battle of Britain]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">Introduction: The Battle of Britain, a critical episode in World War II, holds parallels for project managers and architects in the&#x2026;</p><p class="medium-feed-link"><a href="https://towardsaws.com/learning-from-the-battle-of-britain-ea83a0355e9e?source=rss-ef7179d1f0a3------2">Continue reading on Towards AWS »</a></p></div>]]></description>
            <link>https://towardsaws.com/learning-from-the-battle-of-britain-ea83a0355e9e?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea83a0355e9e</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Sat, 02 Dec 2023 14:17:23 GMT</pubDate>
            <atom:updated>2023-12-03T03:33:02.973Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Mastering API Reliability: The Art of Handling Failures and Retries]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">In the world of software architecture, we encounter APIs everywhere. While we often expect APIs to run flawlessly with 100% uptime, the&#x2026;</p><p class="medium-feed-link"><a href="https://towardsaws.com/mastering-api-reliability-the-art-of-handling-failures-and-retries-2fef0b3dd87d?source=rss-ef7179d1f0a3------2">Continue reading on Towards AWS »</a></p></div>]]></description>
            <link>https://towardsaws.com/mastering-api-reliability-the-art-of-handling-failures-and-retries-2fef0b3dd87d?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/2fef0b3dd87d</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[api-development]]></category>
            <category><![CDATA[api-management]]></category>
            <category><![CDATA[api-integration]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Wed, 13 Sep 2023 20:21:52 GMT</pubDate>
            <atom:updated>2023-09-14T12:30:52.859Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How did I use AWS WAF to protect my API from a replay attack.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://towardsaws.com/how-did-i-use-aws-waf-to-protect-my-api-from-a-replay-attack-5b11aeca7179?source=rss-ef7179d1f0a3------2"><img src="https://cdn-images-1.medium.com/max/947/0*-VS23L4k7JFlVhJU" width="947"></a></p><p class="medium-feed-snippet">It is essential to authenticate almost all APIs, regardless of their purpose. The reason is straightforward: without authentication, they&#x2026;</p><p class="medium-feed-link"><a href="https://towardsaws.com/how-did-i-use-aws-waf-to-protect-my-api-from-a-replay-attack-5b11aeca7179?source=rss-ef7179d1f0a3------2">Continue reading on Towards AWS »</a></p></div>]]></description>
            <link>https://towardsaws.com/how-did-i-use-aws-waf-to-protect-my-api-from-a-replay-attack-5b11aeca7179?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b11aeca7179</guid>
            <category><![CDATA[replay-attack]]></category>
            <category><![CDATA[aws-waf]]></category>
            <category><![CDATA[ddos]]></category>
            <category><![CDATA[aws-security]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Tue, 05 Sep 2023 21:29:17 GMT</pubDate>
            <atom:updated>2023-09-06T04:46:19.382Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Improving Email Deliverability: Understanding and Managing Bounce Rates with AWS SES]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">Introduction</p><p class="medium-feed-link"><a href="https://towardsaws.com/improving-email-deliverability-understanding-and-managing-bounce-rates-with-aws-ses-2fab05845dc0?source=rss-ef7179d1f0a3------2">Continue reading on Towards AWS »</a></p></div>]]></description>
            <link>https://towardsaws.com/improving-email-deliverability-understanding-and-managing-bounce-rates-with-aws-ses-2fab05845dc0?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/2fab05845dc0</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[email-marketing]]></category>
            <category><![CDATA[bounce-rate]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Tue, 20 Jun 2023 12:12:35 GMT</pubDate>
            <atom:updated>2023-06-20T12:12:35.755Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to implement a serverless domain API with AWS.]]></title>
            <link>https://towardsaws.com/how-to-implement-a-serverless-domain-api-with-aws-a42f5143a29?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/a42f5143a29</guid>
            <category><![CDATA[api-gateway]]></category>
            <category><![CDATA[aws-lambda]]></category>
            <category><![CDATA[aws-cog]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Mon, 09 Jan 2023 02:33:59 GMT</pubDate>
            <atom:updated>2023-01-09T10:46:37.536Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’ve read any of my previous articles, you’ll know that I’m working on a portfolio website for myself. It is a static website that is hosted on S3. I’m considering adding a dynamic list to my website. It will list all of my Medium articles.</p><p><strong>The solution.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C9stfklBXoNXzn12" /></figure><p>My API layer is made up of two layers.</p><p><strong>API layer BFF (Backend For Front).</strong><br>The front-end requirement will be facilitated by BFF APIs. Typically, it will use domain API capabilities to invoke domain capabilities and perform business logic. Because this API layer interacts with end users, <strong>authorization and authentication are based on the user session</strong>.</p><p><strong>The API layer for domains.</strong><br>Domain APIs provide domain capabilities. In my case, dealing with article resources can be considered an article domain. Domain APIs should not be called directly from a UI. Instead, the BFF layer should be granted access.<br><strong>To authenticate and authorize domain layer APIs, we use access tokens.</strong></p><p><strong>The domain API.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GaL7orRgJG4AlLsw" /></figure><p>AWS Lambda will be used to dockerize and deploy the Spring Boot API.</p><p><strong>Why is AWS Lamda used?</strong></p><ol><li>I only use the API infrequently. It is not required to run continuously.</li><li>APIs are stateless and complete in milliseconds or less.</li><li>Serverless infrastructure is required.</li></ol><p>AWS provides a wide range of computing services. AWS ECS, AWS EC2, AWS Lambda, and so on. AWS Lambda meets all of the criteria for my use case.</p><p><strong>Why is the API Gateway placed before the Lambda function?</strong></p><ol><li>The API should be able to control the rates that its clients send it.</li><li>If clients exceed the quota, it should be able to throttle requests.</li><li>API authentication should be separated from business logic and moved to a separate layer.</li></ol><p>The first two options are standard API gateway features. The AWS API gateway includes the ability to support the third requirement.<br>AWS API Gateway can be used in conjunction with the AWS Lambda authorizer function or the AWS Cognito user pool.<br>I’m going to stick with the <strong>AWS Cognito user poo</strong>l here. <strong>All requests were cross-checked against the user pool by the API gateway.</strong></p><p><strong>What is AWS WAF doing here?</strong></p><p>APIs are prone to cyber-attacks. Keeping an API publically accessible without protection is a potential risk in many ways. So keeping a layer that can handle OWASP’s top 10 and many more security issues is not a nice to have feature anymore.</p><p><strong>Why did I choose DynamoDB?</strong></p><p>That decision was taken based on two aspects.</p><ol><li>The data model.</li><li>The data access pattern.</li></ol><p>My data model mostly does not follow a fixed schema.</p><p>The data attributes are rarely changing and can be cached. DynamoDB accelerator is used to cache frequently used items. Caching data offer greater benefits.</p><ol><li>It reduces the API response time.</li><li>It reduces DB read operation which leads to lower DynamoDB costs.</li></ol><p>During this article, we discuss how we can implement a domain API with AWS. You may think this is too much for my use case. But keep in mind this is good enough for any enterprise-level API.</p><p>If you think this adds value to you, <strong>please follow and subscribe to </strong>me on Medium to receive my future article.<br>Hint: In my next articles,</p><ol><li>How I’m going to build the infrastructure with Terraform.</li><li>How to implement a BFF API using AWS AppSync ( GraphQL )</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a42f5143a29" width="1" height="1" alt=""><hr><p><a href="https://towardsaws.com/how-to-implement-a-serverless-domain-api-with-aws-a42f5143a29">How to implement a serverless domain API with AWS.</a> was originally published in <a href="https://towardsaws.com/">Towards AWS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to notify Slack for AWS CodePipeline events.]]></title>
            <link>https://towardsaws.com/how-to-notify-slack-for-aws-codepipeline-events-5153e6d5d890?source=rss-ef7179d1f0a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/5153e6d5d890</guid>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[slack]]></category>
            <category><![CDATA[chatops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-codepipeline]]></category>
            <dc:creator><![CDATA[Amith Jayasekara]]></dc:creator>
            <pubDate>Sat, 07 Jan 2023 05:45:24 GMT</pubDate>
            <atom:updated>2023-01-08T07:36:13.761Z</atom:updated>
            <content:encoded><![CDATA[<p>If you remember my previous articles ( links mentioned here as a reference in case you have not read them before ), there I set up a simple static website and a CI/CD pipeline for it.</p><p>Today I plan to move one step ahead from where I was. I thought of how cool it would be if I have all events in my Slack channel. When the pipeline started to grab new codes, ship them to S3, etc, etc.</p><p>Let me take you through the steps I followed.</p><p>First I created a notification rule for my pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m6X3tqKC9B7Ak0AWH5QiWg.png" /></figure><p>rule creation would require a name ( obviously ) and <strong>events </strong>that should be notified and a <strong>target system</strong> that the notification should send.</p><p>Since I would prefer to receive <strong>all the events</strong>, I choose all and <strong>Slack</strong> as the target.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*jlLfv2wT7cwDyy1A7UOVsQ.png" /></figure><p>Since my newly created Slack channel is not yet registered as a target I attempted target creation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/1*F4lVHp1vh4-Ue2bQZP8Ypg.png" /></figure><p>Not it is time for me to configure the chatbot. I create a new client.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_IZsziinW8mj4T26VDvpjQ.png" /></figure><p>AWS offered me two options for the client Slack and AWS Chime, I proceed with Slack and it directed me to Slack for authorization for the Slack workspace.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/679/1*RQCr2gPzgbPnh0rvCC3GzA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*CHXLemEGo6LgPjX7116w6w.png" /></figure><p>Once I authorized, there are a few more additional configurations needed to do.</p><p>What Slack channel should be connected to? What sort of privileges I should allow to the chatbot and what are the guard rules I should create?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-zFvqsK4t9D1H59fsUU_Jg.png" /></figure><p>Since my only intention is to view what&#39;s going on with my CI/CD pipeline, I just set AWS read-only access for both allowed rule and guard conditions.</p><p>With all these details, I did the final step ( clicking the configure button ). Wollah, we are good to test our new integration now.</p><p>I triggered my pipeline and started to flood my channel with all the events.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*YfDcpHJ9zPnnE442KqUE5A.png" /></figure><p>I hope you got something from this. If you like my article, please <strong>follow me</strong> <strong>on Medium</strong> and get notified of my all future articles.</p><p>In case you struggle with any steps, don’t worry I recorded how I did this. Please watch the below video.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FtXy8lYnr3BU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DtXy8lYnr3BU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FtXy8lYnr3BU%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e5c1b3cfc69df6f39886d1d006001330/href">https://medium.com/media/e5c1b3cfc69df6f39886d1d006001330/href</a></iframe><p>references:</p><p>How I host my site using AWS S3.</p><p><a href="https://towardsaws.com/host-your-web-page-with-aws-s3-fa8b7d595292">Host your web page with AWS S3.</a></p><p>How I set up my CI/CD pipeline with AWS CodePipeline.</p><p><a href="https://towardsaws.com/deploy-aws-s3-static-website-with-aws-code-pipeline-3ab55db8a906">Deploy AWS S3 static website with AWS code pipeline.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5153e6d5d890" width="1" height="1" alt=""><hr><p><a href="https://towardsaws.com/how-to-notify-slack-for-aws-codepipeline-events-5153e6d5d890">How to notify Slack for AWS CodePipeline events.</a> was originally published in <a href="https://towardsaws.com/">Towards AWS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>