<?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 Diliru Munasingha on Medium]]></title>
        <description><![CDATA[Stories by Diliru Munasingha on Medium]]></description>
        <link>https://medium.com/@diliru?source=rss-1b8b994522d5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*y49UaYaX0nTbik6u5aN7YQ.jpeg</url>
            <title>Stories by Diliru Munasingha on Medium</title>
            <link>https://medium.com/@diliru?source=rss-1b8b994522d5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 20:50:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@diliru/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[Agentic AI Is Changing How We Think About Software Architecture]]></title>
            <link>https://diliru.medium.com/agentic-ai-is-changing-how-we-think-about-software-architecture-f73faace89e9?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f73faace89e9</guid>
            <category><![CDATA[technology-trends]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Tue, 28 Apr 2026 02:04:13 GMT</pubDate>
            <atom:updated>2026-04-28T02:04:13.726Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vEL7nsoiFWLsHo_qia2n-Q.jpeg" /></figure><p>For most of the last decade, software architecture meant designing systems around predictable inputs and outputs. A function receives data, processes it, returns a result. A service exposes an endpoint. A pipeline moves data from A to B. The mental model was deterministic you could trace every decision back to a line of code someone wrote.</p><p>Agentic AI breaks that mental model completely.</p><p><strong>What Makes a System “Agentic”</strong></p><p>An agent isn’t just a model that answers questions. It’s a system that perceives its environment, makes decisions, executes actions, and adjusts based on what happens next often across multiple steps, tools, and contexts without a human in the loop.</p><p>Think of it less like a function call and more like a junior engineer you’ve handed a task to. You give it a goal. It figures out the steps. It uses the tools available. It recovers when something doesn’t work. And it reports back when it’s done or when it’s stuck.</p><p>That behavioural shift has enormous implications for how we design systems around these agents.</p><p><strong>The Architecture Problem Nobody Is Talking About Enough</strong></p><p>Traditional software is designed to be controlled. Agentic systems are designed to be directed. That’s a fundamentally different contract.</p><p>When you build a system around an agent, you’re no longer just asking “what does this component do?” You’re asking:</p><ul><li>What happens when the agent takes an unexpected path?</li><li>How do we audit decisions made autonomously?</li><li>Where do we draw the boundary between agent authority and human oversight?</li><li>How do we handle failures that aren’t errors in the traditional sense, but wrong judgments?</li></ul><p>These are architectural questions, but they’re also product questions and trust questions. Engineers who only think about them at the infrastructure layer will miss the bigger picture.</p><p><strong>Reliability Looks Different Now</strong></p><p>In classical architecture, reliability means uptime, latency, and error rates. In agentic systems, reliability also means behavioural consistency does the agent do what we intended, across varied contexts, under pressure?</p><p>This demands new thinking around observability. Logging a function call is straightforward. Logging why an agent chose one tool over another, or why it interpreted an ambiguous instruction a certain way, is a genuinely hard problem that the industry is still working through.</p><p><strong>What This Means for Engineers</strong></p><p>The engineers best positioned for this shift are not necessarily those who know the most about model internals. They’re the ones who understand systems deeply who can reason about failure modes, design for uncertainty, and think about human-machine boundaries with clarity.</p><p>Agentic AI doesn’t make software architecture simpler. It makes it richer, more complex, and more consequential. The fundamentals still matter. Systems thinking matters more than ever.</p><p>The tools are changing. The discipline isn’t.</p><p>#AIEngineering #AgenticAI #SoftwareArchitecture #SystemsThinking #TechLeadership #SoftwareEngineering</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f73faace89e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mastering AWS SQS: Simple Tips for Smooth Messaging]]></title>
            <link>https://medium.com/ascentic-technology/mastering-aws-sqs-simple-tips-for-smooth-messaging-5e626f27798c?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e626f27798c</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[sqs]]></category>
            <category><![CDATA[aws-lambda]]></category>
            <category><![CDATA[serverless]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Tue, 12 Nov 2024 10:33:55 GMT</pubDate>
            <atom:updated>2024-11-12T10:33:55.433Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MEdM6at0lte-2MhClaV8fg@2x.jpeg" /></figure><p>Amazon Simple Queue Service (SQS) helps your apps handle messages between services. But to get the best out of SQS, you’ll need to avoid common mistakes and follow some straightforward practices. Here’s a quick guide:</p><ol><li>Set the Right Visibility Timeout</li></ol><p>•	Tip: Visibility timeout is the time a message stays hidden after being received. Set it long enough to finish processing the message but not too long in case processing fails.</p><p>•	Mistake to Avoid: Setting the timeout too short can lead to duplicate processing. Too long, and failed messages get stuck.</p><p>2. Handle Long Tasks Wisely</p><p>•	Tip: If a message takes longer than your Lambda’s allowed time, break it up or use AWS Step Functions.</p><p>•	Mistake to Avoid: Not setting up a dead-letter queue (DLQ) can lead to messages endlessly retrying and racking up costs.</p><p>3. Plan for Repeated Processing</p><p>•	Tip: Design your app to handle duplicates by checking if a message has already been processed (idempotency).</p><p>•	Mistake to Avoid: Ignoring idempotency can lead to issues like duplicate charges or entries.</p><p>4. Monitor with CloudWatch</p><p>•	Tip: Use CloudWatch to keep an eye on message stats and set up alerts for unusual behavior.</p><p>•	Mistake to Avoid: Not having error handling or alerts could leave you with message pile-ups and missed errors.</p><p>5. Use Batch Processing Carefully</p><p>•	Tip: Process messages in batches to save costs, but keep batch sizes manageable to avoid timeouts.</p><p>•	Mistake to Avoid: Grabbing too many messages at once can lead to partial failures and retries.</p><p>6. Leverage Dead-Letter Queues (DLQ)</p><p>•	Tip: DLQs catch messages that fail multiple times so you can fix issues without holding up the main queue.</p><p>•	Mistake to Avoid: Skipping DLQ setup can lead to repeated failures and cost spikes.</p><p>7. Optimize Polling and Processing</p><p>•	Tip: Use long polling for low-traffic queues to reduce empty receives and save money.</p><p>•	Mistake to Avoid: Frequent polling in low-traffic queues increases costs with empty responses.</p><p>8. Secure Your Messages</p><p>•	Tip: Use IAM policies to control access and enable server-side encryption for sensitive messages.</p><p>•	Mistake to Avoid: Over-permissive access can expose your data. Encrypt to keep it safe.</p><p>By setting up proper timeouts, handling errors, using DLQs, and monitoring performance, you can keep your SQS messaging smooth, cost-effective, and secure. Avoiding common mistakes makes SQS a reliable tool to manage communication in your applications without the stress of unexpected costs or message issues.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e626f27798c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/mastering-aws-sqs-simple-tips-for-smooth-messaging-5e626f27798c">Mastering AWS SQS: Simple Tips for Smooth Messaging</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build the right solution, not the biggest: how to avoid over-engineering in software engineering.]]></title>
            <link>https://medium.com/ascentic-technology/build-the-right-solution-not-the-biggest-how-to-avoid-over-engineering-in-software-engineering-1da4ba5efbe9?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1da4ba5efbe9</guid>
            <category><![CDATA[mvp]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Thu, 03 Oct 2024 12:05:39 GMT</pubDate>
            <atom:updated>2024-10-03T12:05:39.902Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cHddxPrmAq0fyNT0-ThkhQ.jpeg" /></figure><p>In software engineering, it’s easy to fall into the trap of over-engineering and building systems that are more complex than necessary. You start simple, but before you know it, your project has multiple layers of abstraction, unnecessary features, and an architecture designed for scalability that may never be needed. This wastes time, increases costs, and makes maintenance a nightmare.</p><p>Over-engineering usually stems from good intentions, future-proofing, perfectionism or a desire to impress. But instead of creating a robust solution, you end up with a bloated one. Here’s how to avoid this common pitfall.</p><h4>Why Over-engineering Happens</h4><ul><li><strong>Future-Proofing</strong>: Designing for problems that may never occur.</li><li><strong>Perfectionism</strong>: Aiming for flawless architecture when a simpler solution would suffice.</li><li><strong>Feature Creep</strong>: Adding unnecessary features just because you can.</li><li><strong>Premature Optimisation</strong>: Optimising performance before you even know if it’s needed.</li></ul><h4>Signs You’re Over-engineering</h4><ul><li>Layers of unnecessary abstractions.</li><li>Too many configurations and unused features.</li><li>Code that no one but you can understand.</li><li>Over-optimisation without real-world data to justify it.</li></ul><h4>How to Avoid Over-engineering</h4><ol><li><strong>Start Simple: Focus on MVP: </strong>Build a <strong>Minimum Viable Product (MVP)</strong> that solves immediate user problems. You can always iterate based on feedback.</li></ol><p><strong>2. Embrace YAGNI (You Aren’t Gonna Need It): </strong>Don’t build features you think might be needed later. Focus on what’s required now. Complexity adds risk, so save extra features for when they become essential.</p><p><strong>3. Prioritise Maintainability: </strong>Simplicity over complexity. Code should be easy to understand and maintain, not a masterpiece only you can decipher. Design systems that your team can work with, without excessive documentation.</p><p><strong>4. Iterate with Feedback: </strong>Release small, functional features quickly and adjust based on actual user needs. This helps avoid unnecessary complexity and ensures you’re solving the right problems.</p><p><strong>5. Communicate with Stakeholders: </strong>Stay aligned with business goals and user needs. Don’t add complexity for hypothetical future issues, build what matters now.</p><p><strong>6. Avoid Premature Optimisation: </strong>Optimise only when data shows performance bottlenecks. Premature optimisation adds complexity without real benefit, making the code harder to change later.</p><p><strong>7. Use Agile Practices: </strong>Agile principles of short sprints and iterative feedback help prevent over-engineering. Focus on delivering value incrementally, with continuous adjustments based on real-world use.</p><h4>Conclusion: Keep It Simple</h4><p>Over-engineering complicates projects unnecessarily. By focusing on simplicity, building iteratively, and optimising only when needed, you’ll create solutions that are practical, maintainable, and scalable without overloading your project with unnecessary complexity. Remember, the goal is to build the right solution, not the most complex one.</p><p>How do you avoid over-engineering? Let me know in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1da4ba5efbe9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/build-the-right-solution-not-the-biggest-how-to-avoid-over-engineering-in-software-engineering-1da4ba5efbe9">Build the right solution, not the biggest: how to avoid over-engineering in software engineering.</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Transactions in MongoDB]]></title>
            <link>https://medium.com/ascentic-technology/understanding-transactions-in-mongodb-a04d991012b3?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/a04d991012b3</guid>
            <category><![CDATA[database-management]]></category>
            <category><![CDATA[nosql]]></category>
            <category><![CDATA[data-integrity]]></category>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[acid-transactions]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Wed, 26 Jun 2024 09:49:01 GMT</pubDate>
            <atom:updated>2024-06-26T09:49:01.823Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PkFtWXp_oFu7xb7W" /><figcaption>Photo by <a href="https://unsplash.com/@rubaitulazad?utm_source=medium&amp;utm_medium=referral">Rubaitul Azad</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>MongoDB supports transactions, enabling multiple operations to be executed in a single logical unit. This ensures data consistency and integrity, especially in complex applications requiring atomicity across multiple documents or collections.</p><p><strong>What is a Transaction? </strong>A transaction in MongoDB allows you to execute a sequence of operations as a single, atomic unit. This means either all operations within the transaction succeed, or none do. If any operation fails, the entire transaction is rolled back, reverting the database to its previous state.</p><p><strong>Key Concepts (ACID)</strong></p><ul><li><strong>Atomicity</strong>: Ensures that all operations within a transaction are completed successfully. If any operation fails, all changes are undone.</li><li><strong>Consistency</strong>: Guarantees that the database remains in a valid state before and after the transaction.</li><li><strong>Isolation</strong>: Ensures that transactions are securely and independently processed without interference.</li><li><strong>Durability</strong>: Once a transaction is committed, changes are permanent, even if the system crashes.</li></ul><p><strong>Using Transactions in MongoDB</strong></p><p>To use transactions in MongoDB, you must be running a replica set or a sharded cluster with MongoDB <strong>4.0 </strong>or later.</p><p><strong>Basic Usage</strong></p><ul><li><strong>Start a Session</strong>: Transactions are associated with client sessions.</li></ul><pre>const session = client.startSession();</pre><ul><li><strong>Begin the Transaction</strong>:</li></ul><pre>session.startTransaction();</pre><ul><li><strong>Perform Operations</strong>:</li></ul><pre>try {<br>    // Operations within the transaction<br>    db.collection(&#39;users&#39;).updateOne({ _id: 1 }, { $set: { name: &#39;Alice&#39; } }, { session });<br><br>    // Commit the transaction<br>    await session.commitTransaction();<br>} catch (error) {<br>    // If an error occurs, abort the transaction<br>    await session.abortTransaction();<br>    throw error;  // Rethrow the error to handle it further up<br>} finally {<br>    // End the session<br>    session.endSession();<br>}</pre><p><strong>Single Collection Transactions vs. Multiple Collection Transactions</strong></p><p><strong>Single Collection Transactions</strong></p><p>Scenario: Transactions involving operations within a single collection.</p><ul><li><strong>Use Case</strong>: Simple operations where updates, inserts or deletes affect only one collection.</li><li><strong>Performance</strong>: Generally faster and less resource-intensive as there are fewer operations to track and manage.</li><li><strong>Example</strong>:</li></ul><pre>const session = client.startSession();<br>session.startTransaction();<br>try {<br>    db.collection(&#39;users&#39;).updateOne({ _id: 1 }, { $set: { name: &#39;Alice&#39; } }, { session });<br>    db.collection(&#39;users&#39;).updateOne({ _id: 2 }, { $set: { name: &#39;Bob&#39; } }, { session });<br>    await session.commitTransaction();<br>} catch (error) {<br>    await session.abortTransaction();<br>    throw error;<br>} finally {<br>    session.endSession();<br>}</pre><p><strong>Multiple Collection Transactions</strong></p><p>Scenario: Transactions involving operations across multiple collections.</p><ul><li><strong>Use Case</strong>: Complex operations where consistency is required across different collections.</li><li><strong>Performance</strong>: Can be slower and more resource-intensive due to the complexity of managing multiple operations across collections.</li><li><strong>Example</strong>:</li></ul><pre>const session = client.startSession();<br>session.startTransaction();<br>try {<br>    db.collection(&#39;users&#39;).updateOne({ _id: 1 }, { $set: { name: &#39;Alice&#39; } }, { session });<br>    db.collection(&#39;accounts&#39;).updateOne({ _id: 1 }, { $inc: { balance: -100 } }, { session });<br>    db.collection(&#39;logs&#39;).insertOne({ event: &#39;Transfer&#39;, amount: 100, date: new Date() }, { session });<br>    await session.commitTransaction();<br>} catch (error) {<br>    await session.abortTransaction();<br>    throw error;<br>} finally {<br>    session.endSession();<br>}</pre><p><strong>Locking Mechanism Behind Transactions</strong></p><p>The locking mechanism in MongoDB ensures that transactions are isolated and consistent. Here’s how it works behind the scenes:</p><ol><li><strong>Document-Level Locks</strong>: MongoDB employs a granular locking system that locks only the documents being modified. This minimizes contention and allows higher concurrency.</li><li><strong>WiredTiger Storage Engine</strong>: MongoDB uses the WiredTiger storage engine, which supports document-level locking. When a transaction modifies a document, WiredTiger acquires a lock on that document, preventing other operations from modifying it until the transaction is committed or aborted.</li><li><strong>Intent Locks</strong>: MongoDB uses intent locks at the collection and database levels. These are lightweight locks that indicate an intent to modify documents within a collection or database. This helps in coordinating more granular document-level locks.</li><li><strong>Two-Phase Locking</strong>: During a transaction, MongoDB follows a two-phase locking protocol, <strong>Growing Phase</strong>: The transaction acquires all the locks it needs as it executes its operations. <strong>Shrinking Phase</strong>: Once all the operations are complete, the transaction releases all the locks.</li><li><strong>Write Concern and Journaling</strong>: MongoDB ensures durability through write concern and journaling. When a transaction is committed, MongoDB writes the changes to the journal before acknowledging the commit, ensuring that changes are not lost even if there is a system crash.</li></ol><p><strong>Example Scenario: Document-Level Locking</strong></p><p>Imagine an application transferring money between two bank accounts. This involves two operations: deducting from one account and crediting another. Document-level locking ensures that these operations can proceed without interference from other operations.</p><pre>async function transferMoney(senderId, receiverId, amount) {<br>    const session = client.startSession();<br>    session.startTransaction();<br>    try {<br>        await db.collection(&#39;accounts&#39;).updateOne({ _id: senderId }, { $inc: { balance: -amount } }, { session });<br>        await db.collection(&#39;accounts&#39;).updateOne({ _id: receiverId }, { $inc: { balance: amount } }, { session });<br>        await session.commitTransaction();<br>        console.log(&quot;Transaction committed.&quot;);<br>    } catch (error) {<br>        await session.abortTransaction();<br>        console.error(&quot;Transaction aborted due to error: &quot;, error);<br>    } finally {<br>        session.endSession();<br>    }<br>}</pre><p>In this scenario, MongoDB locks the documents for the sender’s and receiver’s accounts during the transaction, ensuring no other operation can modify these documents until the transaction completes.</p><p><strong>Issues with Transactions Under Higher Loads</strong></p><p>Implementing transactions in MongoDB under higher loads can introduce several challenges:</p><ul><li><strong>Increased Latency</strong>: Transactions can add latency because they require acquiring and releasing locks, ensuring data consistency, and potentially coordinating across multiple nodes in a replica set or sharded cluster.</li><li><strong>Contention and Deadlocks</strong>: High concurrency can lead to contention for locks, slowing down transactions. Deadlocks may also occur when two or more transactions are waiting for each other to release locks.</li><li><strong>Resource Consumption</strong>: Transactions consume more resources, such as memory and CPU, especially when dealing with large numbers of operations or high concurrency.</li><li><strong>Rollback Overheads</strong>: If a transaction fails and requires a rollback, the system needs to revert all changes, which can be resource-intensive and slow under high load.</li></ul><p><strong>Mitigation Strategies for High Loads</strong></p><ul><li><strong>Optimize Transactions</strong>: Keep transactions short and limit the number of operations within a transaction to reduce lock duration and resource consumption.</li><li><strong>Use Appropriate Write Concern</strong>: Choose a write concern that balances durability with performance. For less critical data, a lower write concern can improve performance.</li><li><strong>Monitor and Tune Performance</strong>: Regularly monitor transaction performance and tune database configurations. Adjust parameters like maxTransactionLockRequestTimeoutMillis to prevent long wait times for locks.</li><li><strong>Scale Out</strong>: Use sharding to distribute the load across multiple nodes. Ensure that transactions are designed to minimize cross-shard operations, which can be more complex and slower.</li><li><strong>Handle Deadlocks Gracefully</strong>: Implement retry logic in your application to handle deadlocks. When a deadlock is detected, abort the transaction and retry after a brief wait.</li><li><strong>Resource Allocation</strong>: Ensure your hardware resources (CPU, memory, I/O) are adequate for the expected load. Use provisioning and scaling strategies to handle peak loads.</li></ul><p><strong>Isolation Levels</strong></p><p>MongoDB supports multiple isolation levels for transactions:</p><ul><li><strong>Read Committed</strong>: Ensures that each read operation within a transaction sees only data that has been committed at the time the read operation starts.</li><li><strong>Repeatable Read</strong>: Guarantees that all reads within a transaction see the same data set. Changes made by other transactions after the transaction starts are not visible.</li></ul><p>These isolation levels allow developers to choose the appropriate level of consistency versus performance for their applications.</p><p><strong>Conclusion</strong></p><p>Transactions in MongoDB provide robust mechanisms for maintaining data integrity and consistency, especially in multi-document and multi-collection operations. The locking mechanism ensures isolation and minimizes contention, allowing developers to handle complex operations reliably. However, under higher loads, transactions can introduce challenges such as increased latency, contention, and resource consumption. By employing optimization strategies, specific error handling, leveraging advanced features like isolation levels, developers can effectively manage and mitigate these issues. This ensures that MongoDB transactions remain efficient and reliable, meeting the demands of modern, data-intensive applications.</p><p>Have I missed anything? Let me know in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a04d991012b3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/understanding-transactions-in-mongodb-a04d991012b3">Understanding Transactions in MongoDB</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[10 things to consider for successful data migration]]></title>
            <link>https://medium.com/ascentic-technology/10-things-to-consider-for-successful-data-migration-41b9666e786d?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/41b9666e786d</guid>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Tue, 16 Jan 2024 06:31:08 GMT</pubDate>
            <atom:updated>2024-01-16T06:31:08.597Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QDlmK_f4IZld1Q-nP_ltqg.jpeg" /></figure><p>Data migration, the process of transferring data between storage types, formats, or systems, is critical in today’s data-driven world. Organizations undertake data migration for various reasons, including system upgrades, consolidation, or moving to cloud platforms. While the benefits are significant, the process can be complex and fraught with challenges. Here are 10 key considerations to ensure smooth and successful data migration.</p><ol><li>Understanding the Scope and Complexity</li></ol><ul><li>Assessment: Thoroughly assess the volume, variety, and complexity of the data to be migrated. Understand dependencies and relationships within the data.</li><li>Goal Setting: Clearly define what you need to achieve with the migration, including performance improvements, cost savings, or enhanced data analytics capabilities.</li></ul><p>2. Choosing the Right Migration Strategy</p><ul><li>Big Bang vs. Phased Approach: Decide whether to move all data at once (Big Bang) or in phases. The Big Bang approach is quicker but riskier, while a phased approach reduces risk but takes longer.</li><li>Backup Strategy: Ensure a robust backup strategy to prevent data loss.</li></ul><p>3. Data Quality and Integrity</p><ul><li>Data Cleaning: Cleanse data before migration to improve quality. Remove duplicates, correct inaccuracies, and fill in missing values.</li><li>Data Integrity: Maintain data integrity during migration. Ensure that relationships between data are preserved and that the migration does not introduce errors.</li></ul><p>4. Compliance and Security</p><ul><li>Regulatory Compliance: Understand and comply with relevant data protection regulations, such as GDPR, HIPAA, etc.</li><li>Security Measures: Implement strong security measures during migration to protect data from breaches, leaks, or unauthorized access.</li></ul><p>5. Choosing the Right Tools and Technology</p><ul><li>Migration Tools: Select appropriate migration tools based on your data types, volume, and the complexity of the migration process.</li><li>Testing Tools: Use tools to validate the migrated data in the new system.</li></ul><p>6. Testing and Validation</p><ul><li>Pre-Migration Testing: Test the migration process in a controlled environment before the actual migration.</li><li>Post-Migration Validation: After migration, validate the data to ensure completeness and accuracy.</li></ul><p>7. Training and Communication</p><ul><li>Stakeholder Engagement: Keep stakeholders informed about the migration process, timelines, and potential impacts.</li><li>Training: Train staff on new systems and processes post-migration.</li></ul><p>8. Managing Downtime and Performance Impact</p><ul><li>Minimizing Downtime: Plan the migration to minimize downtime, which can affect business operations.</li><li>Performance Tuning: Monitor the performance of the new system and make adjustments as necessary.</li></ul><p>9. Planning for Future Scalability</p><ul><li>Scalability: Ensure that the new system can handle future data growth and can be scaled up or down as required.</li></ul><p>10. Documentation and Knowledge Transfer</p><ul><li>Documentation: Document every aspect of the migration process for future reference.</li><li>Knowledge Transfer: Ensure knowledge transfer for ongoing maintenance and management of the new system.</li></ul><p>Data migration is a complex but essential process. By considering these factors, organizations can minimize risks, ensure data integrity, and make the migration process as seamless as possible. Thorough planning, choosing the right tools and strategies, and ensuring compliance and security are key to a successful data migration. Remember, the goal is not just to move data but to enhance its value and utility in its new environment.</p><p>Thanks for reading! If you have any more tips to add, please feel free to let me know in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41b9666e786d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/10-things-to-consider-for-successful-data-migration-41b9666e786d">10 things to consider for successful data migration</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Crafting Your AWS VPC for an MVP: A Systematic Guide]]></title>
            <link>https://medium.com/ascentic-technology/crafting-your-aws-vpc-for-an-mvp-a-systematic-guide-4c51e17e07da?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c51e17e07da</guid>
            <category><![CDATA[mvp]]></category>
            <category><![CDATA[mvp-development]]></category>
            <category><![CDATA[virtual-private-cloud]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[vpc]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Tue, 19 Sep 2023 05:24:46 GMT</pubDate>
            <atom:updated>2023-09-19T05:24:46.182Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/472/1*g4Y-NGq3WAOBCuSA50iaqQ.png" /></figure><p>As you embark on your AWS MVP project, you’re likely to encounter the term VPC (Virtual Private Cloud). But what exactly is it, and how can you configure it effectively for your startup’s minimum viable product? In this article, we will systematically explore the essentials of setting up an AWS VPC for your MVP project, using real-world scenarios.</p><h4>1. Define Your Project Scope</h4><p>Imagine you’re launching a new e-commerce website for selling handmade goods. Defining your project’s scope involves specifying the initial requirements. In the MVP context, this might entail creating a basic web application and a database to manage products and orders.</p><h4>2. VPC Design: Start Small, Plan for Growth</h4><p>Your VPC serves as the foundational infrastructure for your project. It’s similar to selecting the ideal workspace for your startup. Your VPC should be adequately sized to meet your current needs while allowing room for future expansion.</p><ul><li>VPC Size: Choose an IP address range (CIDR block) that aligns with your present resource requirements and accommodates future growth.</li><li>Subnet Configuration: Organize your VPC into public and private subnets. Public subnets host web servers and load balancers, while private subnets house databases and application servers.</li><li>Availability Zones: Spread your resources across multiple Availability Zones for redundancy and fault tolerance.</li></ul><h4>3. Strengthen Security</h4><p>Security is paramount. Configure your VPC’s security just as you would secure the premises of your physical store.</p><ul><li>Security Groups: Think of these as the locks on your virtual doors. Configure them to permit only essential traffic.</li><li>Network ACLs: Network Access Control Lists (ACLs) serve as an additional layer of security, controlling traffic at the subnet level, similar to security measures within your workspace.</li></ul><h4>4. Establish Internet Connectivity</h4><p>Much like your brick-and-mortar store requires customer access, your VPC needs internet connectivity.</p><ul><li>Internet Gateway: Attach this component to your VPC for internet access and configure route tables to direct traffic accordingly.</li><li>NAT Gateway: If private resources require outbound internet access (e.g., for software updates), establish NAT gateways in public subnets.</li></ul><h4>5. Carefully Configure Routing</h4><p>Routing tables within your VPC act like providing directions to your store. Ensure they guide traffic effectively.</p><h4>6. Vigilant Monitoring</h4><p>Just as you would track sales and inventory in your physical store, monitoring and logging are essential for your VPC.</p><ul><li>CloudWatch: This functions as your virtual CCTV system. Utilize it to monitor your resource performance.</li><li>Alarms and Notifications: Set up alarms to proactively address issues and receive timely notifications.</li></ul><h4>7. Data Protection</h4><p>Similar to safeguarding your valuable assets, data protection is of utmost importance.</p><ul><li>Backup Strategy: Ensure your database incorporates backup and recovery mechanisms.</li></ul><h4>8. Scaling for Success</h4><p>As your venture gains traction, scalability becomes crucial.</p><ul><li>Auto Scaling: Picture this as hiring additional staff during peak demand.</li><li>Elastic Load Balancing: It’s akin to having extra support staff to handle increased activity.</li></ul><h4>9. Cost Management</h4><p>Like any successful business, operating within a budget is essential.</p><ul><li>Cost Optimization: Regularly review and optimize your VPC to minimize unnecessary expenditure.</li></ul><h4>10. Thorough Documentation</h4><p>Just as meticulous record-keeping is vital for your business, maintain clear and comprehensive documentation for your VPC configurations.</p><h4>11. Compliance and Security</h4><p>Adhere to AWS best practices and any industry-specific compliance requirements applicable to your project.</p><h4>12. Disaster Recovery</h4><p>Prepare a robust plan for when things go awry. Automated backups and resource recovery protocols serve as lifelines.</p><h4>13. Testing and Monitoring</h4><p>Thoroughly test your setup and continuously monitor it throughout your project’s development and deployment phases.</p><h4>14. Automation through Infrastructure-as-Code</h4><p>Tools like AWS CloudFormation are akin to using precise blueprints for your infrastructure, ensuring efficiency and reliability.</p><p>Configuring your AWS VPC for an MVP is a systematic endeavour, demanding meticulous planning and attention to detail. With a well-thought-out design and a focus on scalability, your AWS VPC can serve as the foundational infrastructure where your MVP project evolves into a full-fledged venture. Begin conservatively, envision growth, and adapt as your business flourishes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c51e17e07da" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/crafting-your-aws-vpc-for-an-mvp-a-systematic-guide-4c51e17e07da">Crafting Your AWS VPC for an MVP: A Systematic Guide</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Distributed Tracing: Key Insights]]></title>
            <link>https://medium.com/ascentic-technology/distributed-tracing-key-insights-f732137db42c?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f732137db42c</guid>
            <category><![CDATA[microservices-testing]]></category>
            <category><![CDATA[serverless-monitoring]]></category>
            <category><![CDATA[aws-x-ray]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Tue, 11 Apr 2023 16:31:51 GMT</pubDate>
            <atom:updated>2023-04-17T12:54:35.210Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5NxwBmOknO8HEdVdB7uJkQ.jpeg" /></figure><p>Distributed tracing is a technique used to monitor and debug complex software systems, such as those built using microservices architecture or serverless computing. It involves the collection and aggregation of trace data from multiple components or services involved in processing a single user request or transaction.</p><p>In a distributed system, a single request or transaction may traverse multiple services or components, each of which may be running on a different server or node. Distributed tracing allows developers to track the flow of these requests or transactions across multiple services and identify performance bottlenecks, errors, or latency issues.</p><p>This technique works by generating trace data at each service or component involved in processing a request or transaction. This trace data includes information such as the service or component name, the start and end times of the request or transaction, any errors encountered, and any data transformations or actions performed. This trace data is then propagated to a central repository or tracing system, where it can be aggregated and analyzed to provide a comprehensive view of the entire request or transaction flow.</p><p>There are two main reasons to use distributed tracing in a distributed software system:</p><ol><li>Performance monitoring: Distributed tracing allows developers to monitor the performance of each service or component involved in processing a request or transaction. This can help identify bottlenecks or areas where performance can be improved.</li><li>Troubleshooting and debugging: Distributed tracing allows developers to identify errors or latency issues in a request or transaction flow, making it easier to troubleshoot and debug issues.</li></ol><p>Apart from these two obvious reasons distributed tracing might be helpful for,</p><ol><li>Optimization: Distributed tracing can help developers identify areas of the system where optimization can be done to improve performance, reduce latency, or minimize errors.</li><li>Scaling: Distributed tracing can help developers understand how services and components are interacting with each other, making it easier to scale the system horizontally or vertically.</li></ol><p>In order to understand this concept here’s an example of distributed tracing in serverless computing,</p><ul><li>An HTTP request is sent to a serverless function to store data into a database.</li><li>The serverless function triggers another function to transform the data.</li><li>The second function triggers a third function to store the transformed data in a data store.</li><li>The third function returns a response to the second function.</li><li>The second function returns a response to the first function.</li><li>The first function returns a response to the original HTTP request.</li></ul><p>In this example, each function generates its own trace data, which includes information such as function name, start and end times, and any errors that occurred during execution. The tracing system correlates the trace data from all the functions involved in the request, providing developers with a complete view of the request flow and performance.</p><p>There are many distributed tracing services available, both open-source and commercial. Here are some of the most popular ones:</p><ul><li>AWS X-Ray: A distributed tracing service provided by Amazon Web Services.</li><li>Google Cloud Trace: A distributed tracing service provided by Google Cloud.</li><li>Jaeger: An open-source distributed tracing system developed by Uber.</li><li>Zipkin: An open-source distributed tracing system developed by Twitter.</li></ul><p>In summary, distributed tracing is a powerful technique for monitoring and debugging complex software systems, especially those built using microservices architecture or serverless computing. By providing a comprehensive view of request or transaction flow across multiple services and components, it helps developers identify performance bottlenecks, troubleshoot and debug issues, optimize the system, and scale the system horizontally or vertically.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f732137db42c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/distributed-tracing-key-insights-f732137db42c">Distributed Tracing: Key Insights</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Considering going serverless??]]></title>
            <link>https://medium.com/ascentic-technology/considering-going-serverless-a5d2f8eadfcc?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5d2f8eadfcc</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[lambda]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Tue, 21 Mar 2023 16:50:42 GMT</pubDate>
            <atom:updated>2023-03-22T07:39:07.524Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KOTwp96t0-qxfboQnbexrQ.png" /></figure><p>Serverless computing architecture has been one of the major trends in software engineering in the recent past. Serverless architecture is a cloud computing model in which the cloud provider manages the infrastructure and automatically allocates computing resources as needed to run applications, without the need for the user to manage the underlying server infrastructure.</p><p>In a serverless architecture, applications are built and deployed as individual functions or microservices, which can be executed in response to specific events or triggers, such as HTTP requests, database updates, or message queue events. These functions are typically short-lived, stateless, and can be executed in parallel to handle high traffic loads.</p><p>When designing a serverless architecture, there are several things to consider to ensure that your application runs efficiently, securely, and cost-effectively. Here are some of the key things to keep in mind:</p><ol><li>Function granularity: Break down your application logic into small, focused functions that perform a specific task. This helps to optimize resource usage and minimize cold start times.</li><li>Scalability: Ensure that your architecture can handle sudden spikes in traffic and that it can scale up or down automatically based on demand.</li><li>Security: Implement robust security measures to protect your application against common threats such as SQL injection, cross-site scripting (XSS), and cross-site request forgery (CSRF).</li><li>Performance: Optimize your code and configurations for fast and reliable performance, and ensure that your architecture is optimized for the specific workload and use case.</li><li>Integration: Ensure that your serverless architecture can easily integrate with other services and platforms, such as databases, storage, and messaging services.</li><li>Monitoring: Set up effective monitoring and logging systems to track performance, detect errors and anomalies, and identify areas for optimization.</li><li>Cost optimization: Optimize your architecture to minimize costs by using pay-as-you-go pricing models, minimizing resource usage, and leveraging cost-saving strategies such as resource sharing and serverless computing.</li></ol><p>By considering these factors, you can design a serverless architecture that is secure, scalable, performant, and cost-effective, and that meets the needs of your specific workload and use case.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5d2f8eadfcc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ascentic-technology/considering-going-serverless-a5d2f8eadfcc">Considering going serverless??</a> was originally published in <a href="https://medium.com/ascentic-technology">Ascentic Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Infrastructure as Code??]]></title>
            <link>https://diliru.medium.com/infrastructure-as-code-9741f95a88d5?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/9741f95a88d5</guid>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Sat, 04 Mar 2023 19:26:19 GMT</pubDate>
            <atom:updated>2023-03-04T19:26:19.901Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dBDyARC9eqt8Hhzx3M6_WQ.png" /></figure><p>Infrastructure as code (IaC) is an approach to managing infrastructure resources using code instead of manual configuration. With IaC, infrastructure is treated as software and is defined, provisioned, and managed using the same techniques and tools that are used for software development.</p><p>IaC involves defining infrastructure resources in a declarative way using code, typically in a high-level programming language or domain-specific language. The code specifies the desired state of the infrastructure, including the configuration of servers, networks, storage, and other resources.</p><p>Once the code is defined, it can be version controlled, tested, and deployed using automated tools and processes. Changes to the infrastructure can be made by modifying the code and then running automated scripts to apply those changes.</p><p>IaC provides several benefits over traditional infrastructure management approaches, including:</p><ol><li>Consistency</li></ol><p>With IaC, infrastructure resources are defined consistently and reproducibly using code, reducing the risk of human error and ensuring that the same configuration is used across all environments.</p><p>2. Scalability</p><p>IaC makes it easier to manage large and complex infrastructures, by providing a scalable and repeatable way to provision and manage resources.</p><p>3. Speed</p><p>IaC allows for faster and more reliable infrastructure deployment and management, by automating many of the manual tasks involved in infrastructure provisioning.</p><p>4. Collaboration</p><p>IaC promotes collaboration between development and operations teams, by providing a common language and toolset for managing infrastructure resources.</p><p>5. Security</p><p>IaC allows for more secure infrastructure management, by ensuring that security controls are defined and enforced consistently across all environments.</p><p><strong>There are several possible paths to implementing IaC:</strong></p><ol><li>Cloud-native approach:</li></ol><p>This approach involves using cloud-native tools and services provided by cloud providers, such as AWS CloudFormation, Google Cloud Deployment Manager, and Azure Resource Manager. These tools provide declarative templates to define infrastructure resources, which can be versioned and deployed in a consistent and repeatable way.</p><p>2. Configuration Management approach</p><p>This approach involves using configuration management tools such as Ansible, Puppet, or Chef to manage infrastructure resources. These tools allow you to define infrastructure as code, manage configurations, and enforce consistency across all environments.</p><p>3. Container Orchestration approach</p><p>This approach involves using container orchestration tools such as Kubernetes or Docker Swarm to manage infrastructure resources. These tools allow you to define infrastructure as code using YAML files or other declarative languages and automate the deployment, scaling, and management of containerized applications.</p><p>4. Serverless approach</p><p>This approach involves using serverless computing platforms such as AWS Lambda, Azure Functions, or Google Cloud Functions to manage infrastructure resources. Serverless platforms allow you to define infrastructure resources using code and deploy them as functions or services, which are automatically scaled and managed by the platform.</p><p><strong>Here are some examples of how IaC can be used:</strong></p><ol><li>AWS CloudFormation</li></ol><p>AWS CloudFormation is a service provided by Amazon Web Services (AWS) that enables you to define infrastructure resources using templates written in JSON or YAML. You can use CloudFormation to define and deploy entire cloud environments, including virtual machines, databases, and networking resources, all in a repeatable and automated way.</p><p>2. Ansible</p><p>Ansible is a popular configuration management tool that enables you to define infrastructure resources using a high-level, human-readable language. You can use Ansible to manage configurations, automate repetitive tasks, and enforce consistency across all environments. Ansible provides a wide range of modules that can be used to manage infrastructure resources such as servers, databases, and networking devices.</p><p>3. Kubernetes</p><p>Kubernetes is an open-source container orchestration platform that enables you to manage and deploy containerized applications at scale. With Kubernetes, you can define infrastructure resources such as containers, volumes, and networking resources using YAML files. Kubernetes also provides powerful tools for managing and scaling applications, including load balancing, automatic scaling, and self-healing.</p><p>4. Terraform</p><p>Terraform is an open-source infrastructure as code tool that enables you to define, provision, and manage infrastructure resources across multiple cloud providers. With Terraform, you can define infrastructure resources using a high-level configuration language, which is then deployed using Terraform’s command line interface. Terraform also provides a “plan and apply” workflow, which enables you to preview infrastructure changes before applying them to production environments.</p><p>Overall, IaC provides a powerful and consistent way to manage infrastructure resources, by treating infrastructure as code and automating many of the manual tasks involved in infrastructure provisioning and management.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9741f95a88d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Simple Comparison Between DynamoDB and MongoDB]]></title>
            <link>https://diliru.medium.com/a-simple-comparison-between-dynamodb-and-mongodb-ecb20036a0a1?source=rss-1b8b994522d5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ecb20036a0a1</guid>
            <dc:creator><![CDATA[Diliru Munasingha]]></dc:creator>
            <pubDate>Sat, 04 Mar 2023 19:10:13 GMT</pubDate>
            <atom:updated>2023-03-04T19:10:13.814Z</atom:updated>
            <content:encoded><![CDATA[<p>DynamoDB and MongoDB are both popular NoSQL databases, but they differ in several ways. Here are some of the key differences between DynamoDB and MongoDB:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*fZt6jxTKhJtnxs_N33nKKQ.png" /></figure><ol><li>Data Model:</li></ol><p>MongoDB is a document-based database, which means that data is stored in JSON-like documents. Documents can contain nested structures, arrays, and other complex data types. DynamoDB, on the other hand, is a key-value store that uses a hash key and optional sort key to uniquely identify each item.</p><p>2. Scalability:</p><p>DynamoDB is designed to be highly scalable and can automatically distribute data across multiple servers to handle high levels of traffic. MongoDB can also be scaled horizontally, but it requires more manual effort to set up and manage a sharded cluster.</p><p>3. Consistency Model:</p><p>DynamoDB uses a “eventually consistent” model by default, which means that it may take some time for changes made to the database to propagate across all replicas. MongoDB provides more options for consistency, including strong, eventual, and causal consistency.</p><p>4. Querying:</p><p>MongoDB provides a powerful querying language that allows for complex queries using a variety of operators and functions. DynamoDB, on the other hand, provides limited querying capabilities and requires careful consideration of the data model to design efficient queries.</p><p>5. Pricing:</p><p>DynamoDB pricing is based on the amount of data stored and the number of read and write requests made to the database. MongoDB pricing is based on the number of instances and the amount of storage used.</p><p>In summary, DynamoDB is a highly scalable, key-value store designed for low-latency, high-throughput applications, while MongoDB is a document-based database with a powerful querying language that is best suited for applications that require flexible data models and complex querying. The choice between DynamoDB and MongoDB ultimately depends on the specific needs of the application, such as scalability, data model, consistency, and querying requirements.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ecb20036a0a1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>