<?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 Ricardo Torres on Medium]]></title>
        <description><![CDATA[Stories by Ricardo Torres on Medium]]></description>
        <link>https://medium.com/@rictorres.uyu?source=rss-a3be19ac3978------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*o2EMT8U981Y9zQeCD_gJ5w.jpeg</url>
            <title>Stories by Ricardo Torres on Medium</title>
            <link>https://medium.com/@rictorres.uyu?source=rss-a3be19ac3978------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 08:53:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rictorres.uyu/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[How Modern Enterprises Are Migrating Legacy .NET Monoliths to Scalable Cloud Architectures]]></title>
            <link>https://medium.com/@rictorres.uyu/how-modern-enterprises-are-migrating-legacy-net-monoliths-to-scalable-cloud-architectures-82b65edd2127?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/82b65edd2127</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Thu, 05 Mar 2026 15:46:06 GMT</pubDate>
            <atom:updated>2026-03-05T15:46:06.741Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z8THzcN4MeFpYDrpWewXwQ.png" /></figure><p>Modern enterprises across industries are facing the same challenge: <br><strong>their core systems were built many years ago and are now struggling to scale, evolve, and integrate with modern cloud platforms.</strong></p><p>Many of these systems were originally designed as <strong>large monolithic applications</strong>, often running on older frameworks, tightly coupled to massive relational databases, and difficult to maintain.</p><p>Today, organizations are modernizing these platforms to support:</p><p>- cloud scalability<br>- faster development cycles<br>- improved security<br>- independent teams<br>- continuous delivery</p><p>This article explores how modern engineering teams are evolving legacy platforms into <strong>scalable cloud architectures</strong> using proven architectural patterns.</p><h3>The Legacy Monolith Problem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*NJGE7eliigtL6uIKw1qmXA.gif" /></figure><p>Many enterprise platforms were originally built as <strong>monolithic applications</strong> where:</p><p>- business logic<br>- data access<br>- UI<br>- integrations</p><p>are tightly coupled into a single deployable unit.</p><p>While this approach worked well initially, over time several problems appear:</p><p>- deployments become risky<br>- development slows down<br>- scaling becomes difficult<br>- teams step on each other’s changes<br>- testing becomes complex</p><p>As systems grow, the monolith becomes a <strong>bottleneck for innovation</strong>.</p><h3>Modernization Strategy: Start with a Modular Monolith</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dN6XdIo-ghrQSUZ6-AxCnQ.png" /></figure><p>One common mistake organizations make is attempting to immediately break a monolith into microservices.</p><p>In practice, a safer and more effective approach is to first evolve the system into a <strong>modular monolith.</strong></p><p>A modular monolith introduces clear <strong>domain boundaries</strong> inside the application.</p><p>Each module:</p><p>- owns its domain logic<br>- exposes APIs internally<br>- isolates dependencies</p><p>This provides many benefits:</p><p>- clear separation of concerns<br>- easier testing<br>- simpler refactoring<br>- lower operational complexity</p><p>Only once domains become stable does it make sense to extract them into independent services.</p><h3>Clean Architecture as the Foundation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lpjyaSiKFNKd7kktJvNfEQ.png" /></figure><p>Modern enterprise systems often adopt <strong>Clean Architecture</strong> to improve maintainability.</p><p>Clean Architecture organizes applications into layers:</p><p>- <strong>Domain Layer</strong> — core business rules<br>- <strong>Application Layer </strong>— use cases and orchestration<br>- <strong>Infrastructure Layer</strong> — databases, messaging, APIs<br>- <strong>Presentation Layer </strong>— web APIs or UI</p><p>The key principle is the <strong>dependency rule</strong>:</p><p>&gt; Inner layers must never depend on outer layers.</p><p>This ensures the domain remains independent of frameworks, databases, or infrastructure.</p><h3><strong>API-Driven Platforms</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BwBgrnPNUoT5OmELjqC6Eg.png" /></figure><p>Modern enterprise platforms expose functionality through <strong>RESTful APIs</strong>.</p><p>APIs allow:</p><p>- frontend applications<br>- partner integrations<br>- mobile applications<br>- internal services</p><p>to interact with the platform consistently.</p><p>Best practices include:</p><p>- resource-based endpoints<br>- proper HTTP verbs<br>- clear status codes<br>- pagination for large datasets<br>- idempotent operations</p><h3>Micro Frontends for Large UI Platforms</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XSYkh_5lXHaOK2JRL_NB5w.png" /></figure><p>Large organizations often have many teams working on the same frontend application.</p><p>To reduce coupling, teams are adopting <strong>micro frontend architectures.</strong></p><p>In this model:</p><p>- a <strong>Shell application</strong> provides the base layout<br>- individual features are implemented as <strong>independent frontend modules</strong><br>- teams can deploy UI features independently</p><p>This improves scalability and allows multiple teams to work without interfering with each other.</p><h3>Secure Identity and Access in the Cloud</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QU-JMg9j8v5WYQXzTs82oQ.png" /></figure><p>Security is a critical aspect of modern enterprise platforms.</p><p>Cloud-native architectures often rely on <strong>identity-based access instead of credentials</strong>.</p><p>Modern identity patterns include:</p><p>- centralized identity providers<br>- token-based authentication<br>- role-based access control (RBAC)</p><p>This approach allows applications to securely access cloud services without storing secrets.</p><h3>DevOps and Continuous Delivery</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LOLu1UmkOglodzEbpCfyig.png" /></figure><p>Modern platforms require reliable deployment strategies.</p><p>Enterprise teams are moving toward <strong>continuous integration and continuous delivery (CI/CD)</strong> pipelines.</p><p>Typical pipeline stages include:</p><p>1. Build and unit tests<br>2. Static code analysis<br>3. Security scanning<br>4. Artifact publishing<br>5. Deployment to staging environments<br>6. Production deployment</p><p>Deployment strategies such as <strong>Blue-Green deployments</strong> allow teams to release new versions safely with minimal downtime.</p><h3>Feature Flags for Safer Releases</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FAUM2QZWoB1mEAudycHmsQ.png" /></figure><p>A powerful technique used by many organizations is <strong>feature flagging</strong>.</p><p>Feature flags allow teams to:</p><p>- release code without enabling functionality<br>- enable features for specific users<br>- perform gradual rollouts<br>- instantly disable problematic features</p><p>This dramatically reduces deployment risk.</p><h3>Infrastructure as Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z3o73zc-mvHKAWLX58XC-Q.png" /></figure><p>Modern cloud platforms are defined using <strong>Infrastructure as Code (IaC)</strong>.</p><p>Instead of manually configuring environments, teams define infrastructure using code.</p><p>Benefits include:</p><p>- reproducible environments<br>- version control<br>- automated provisioning<br>- easier scaling</p><p>This approach enables consistent infrastructure across development, testing, and production environments.</p><h3>The Future of Enterprise Platforms</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vQAcJC2syNnOmTMeisg6Wg.png" /></figure><p>Enterprise modernization is not about rewriting everything overnight.</p><p>Successful organizations follow an <strong>incremental modernization strategy</strong>:</p><p>1. stabilize the monolith<br>2. introduce modular boundaries<br>3. adopt cloud infrastructure<br>4. expose APIs<br>5. scale frontend teams<br>6. automate deployment pipelines</p><p>Over time, this evolution transforms legacy systems into <strong>resilient, scalable, cloud-native platforms</strong>.</p><h3>🚀 What I’m Seeing Across the Industry</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*Tteuw-j2D5HdxzcjJKmq3A.gif" /></figure><p>From my research and conversations with engineering teams, one thing is becoming clear:</p><p>Modernizing enterprise platforms is not about <strong>massive rewrites</strong>. <br>The companies doing it successfully are evolving their systems step by step.</p><p>🧩 Stabilizing legacy systems <br>⚙️ Introducing modular architectures <br>🔌 Exposing capabilities through APIs <br>☁️ Moving infrastructure to the cloud <br>🚀 Automating deployments and scaling teams</p><p>The real goal isn’t just adopting new technology.</p><p>It’s building <strong>platforms that can keep evolving for the next decade.</strong></p><p>😊 I’m curious about your experience.</p><p>Are you modernizing applications in your organization?</p><p>- Are you using <strong>microservices or modular monoliths?<br></strong>- Are you adopting <strong>micro frontends?</strong><br>- What <strong>DevOps or deployment strategies</strong> are working for you?</p><p>💬 If this resonates with you, feel free to <strong>leave a comment and share what your team is doing.</strong><br>I’d love to learn how different companies are approaching modernization.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82b65edd2127" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-Driven Migration: A Strategic Roadmap from AngularJS to Angular 21]]></title>
            <link>https://medium.com/@rictorres.uyu/ai-driven-migration-a-strategic-roadmap-from-angularjs-to-angular-21-7045c6826629?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/7045c6826629</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[angularjs]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Mon, 16 Feb 2026 01:05:43 GMT</pubDate>
            <atom:updated>2026-02-16T01:05:43.719Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R1RI3FQ5uAvP6uhTn8teTQ.png" /></figure><h3>Migration Phases: A Structured, Low-Risk Approach</h3><p>Before starting any AngularJS → Angular 21 migration, companies must understand one critical reality:</p><p>Migration is <strong>not just technical</strong>. It is <strong>strategic, operational, and architectural</strong>.</p><p>Without a structured plan, risk increases dramatically.</p><h4>⚠️ Migration Risks to Consider First</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MVvxcAR124h93FLYsJnr1Q.png" /></figure><p>Before discussing phases, let’s address risks:</p><h4>1️⃣ Deprecated or Unsupported Libraries</h4><p>Many AngularJS systems rely on:<br>- jQuery plugins (e.g., jQuery datepicker)<br>- Legacy UI widgets<br>- Custom directives tightly coupled to DOM manipulation<br>- Third-party libraries no longer maintained</p><p>Some of these <strong>cannot be reused in Angular 21</strong>.</p><p>Example:<br>- A jQuery calendar widget must be replaced with:<br> — Angular Material Datepicker<br> — A Tailwind-based calendar component<br> — Or a custom-built Angular standalone component</p><p>You are not migrating code.<br>You are <strong>recreating behavior in a modern, maintainable way</strong>.</p><h4>2️⃣ Hidden Dependencies</h4><p>Legacy systems often contain:<br>- Implicit global variables<br>- Hardcoded endpoints<br>- Inline scripts<br>- Cross-module coupling</p><p>These must be discovered before planning the migration.</p><h4>🛠️ Phase 1 — Intelligent Legacy Exploration (AI-Powered Discovery)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uX6qxuYldUiekTOeUiTFQA.gif" /></figure><p>The first phase is not rewriting.<br>It is <strong>understanding</strong>.</p><p>Using a Python script enhanced with OpenAI intelligence, the system is scanned to generate:</p><p>- <strong>Views</strong> and <strong>templates</strong><br>- <strong>Controllers</strong> and <strong>services</strong><br>- Routing structure<br>- <strong>API</strong> calls<br>- Form behaviors<br>- <strong>CRUD</strong> patterns<br>- Sensitive configurations<br>- Suggested entities and database schema<br>- Inferred use cases and business flows</p><p>This is not simple static analysis.<br>It is semantic interpretation powered by AI.</p><p>At the end of this phase, you have:</p><p>- A complete inventory<br>- Identified dependencies<br>- Identified technical risks<br>- Suggested architectural directions<br>- Estimated complexity per module</p><p>This becomes your migration blueprint.</p><h4>📋 Phase 2 — Backlog Creation &amp; Prioritization</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x_pYIHrsoUlm3s4tkDZkdQ.png" /></figure><p>Once the inventory is complete:</p><p>1. All identified artifacts become backlog items.<br>2. Each module or feature is converted into:<br> — User stories<br> — Technical tasks<br> — Refactoring tasks<br> — Replacement tasks (e.g., replacing jQuery calendar)</p><p>The team then:</p><p>- Estimates effort<br>- Identifies dependencies<br>- Defines priorities<br>- Aligns with business impact</p><p>At this stage, the organization has clarity:</p><p>- What exists<br>- What must be rebuilt<br>- What can be reused<br>- What must be replaced<br>- What is critical<br>- What can wait</p><p>This prevents blind migration.</p><h4>🔄 Phase 3 — Incremental Migration Using ngUpgrade</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ydZWByQiIBisOkpbvRB7-Q.png" /></figure><p>Technically, the safest and most powerful strategy is:</p><p><strong>Hybrid Migration with ngUpgrade</strong></p><p>Angular allows both frameworks to coexist temporarily.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yMISG7vSZv0vnCWXY7isUQ.png" /></figure><p>Imagine being hired to modernize a building, and instead of tearing it down, you upgrade it floor by floor — keeping it fully operational while transforming it into something modern and stronger. That’s exactly how incremental migration works… and honestly, I think that’s <strong>fantastic.</strong> 🙂</p><p>This means:</p><p>- AngularJS continues running.<br>- New Angular 21 components are introduced gradually.<br>- Old components are replaced piece by piece.</p><p>The application becomes hybrid:</p><p>- Part legacy<br>- Part modern</p><p>This approach enables:</p><p>- Zero business interruption<br>- Controlled risk<br>- Continuous delivery<br>- Parallel feature development</p><p>The legacy system is not abruptly shut down.</p><p>Instead:</p><p>The new system is born while the old one is slowly turned off.</p><p>This is one of the most elegant strategies in enterprise modernization.</p><h4>🧩 Phase 4 — Component Replacement &amp; UI Modernization</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SlUp7tBXVx-AgcztldV8zQ.png" /></figure><p>This is one of my favorite phases — giving the app a fresh <strong>look and feel</strong> and elevating the user experience. It’s not just about functionality; it’s about making <strong>users love the experience</strong> 🚀</p><p>During incremental migration:</p><p>- jQuery widgets are replaced.<br>- Custom directives are rewritten.<br>- AngularJS controllers become Angular services.<br>- Two-way bindings are redesigned using Signals.</p><p>UI can be modernized using:</p><p>- Angular Material<br>- TailwindCSS<br>- Bootstrap<br>- Bulma<br>- Or a dedicated UI/UX redesign initiative</p><p>This is where UX transformation happens.</p><h4>🧪 Phase 5 — Testing &amp; Stability Reinforcement</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IQuiIKXjcPf7LYP-PkrzOA.png" /></figure><p>This phase is extremely important to me, because solid testing directly increases the <strong>quality of the application</strong>. The more we test, the more confidence we build in the product and in every release we deliver.</p><p>For each migrated piece:</p><p>- Backend unit tests (.NET)<br>- Frontend unit tests (Angular)<br>- Integration testing<br>- Regression validation</p><p>This ensures:</p><p>- Legacy functionality is preserved<br>- New functionality behaves correctly<br>- No hidden regressions appear</p><p>Migration without testing is controlled chaos.</p><h4>🚀 Phase 6 — Gradual Decommissioning</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JHklTV9PQebDlYG2YzDuSQ.png" /></figure><p>As features are replaced:</p><p>- AngularJS modules are removed<br>- Deprecated libraries are eliminated<br>- Technical debt is reduced</p><p>Eventually:</p><p>- The AngularJS runtime is fully removed<br>- The system runs entirely on Angular 21</p><p>At this point, modernization is complete.</p><h4>🔁 Recommended Migration Flow Summary</h4><p>1. Risk assessment<br>2. AI-powered legacy exploration<br>3. Inventory generation<br>4. Backlog creation and estimation<br>5. Incremental migration with ngUpgrade<br>6. UI modernization and library replacement<br>7. Testing and validation<br>8. Legacy decommissioning</p><p>If this article was helpful for your <strong>migration journey</strong>, let me know in the comments — I’d love to hear your thoughts.</p><p>What other factors would you consider when migrating from <strong>AngularJS</strong>?</p><p>And if you enjoyed it, feel free to subscribe for more insights on <strong>modern architecture and enterprise modernization</strong>.</p><p>Thank you for reading 🙏🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7045c6826629" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automating Business Processes with .NET, Angular, and AI]]></title>
            <link>https://medium.com/@rictorres.uyu/automating-business-processes-with-net-angular-and-ai-25db2e526578?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/25db2e526578</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Tue, 13 Jan 2026 16:56:13 GMT</pubDate>
            <atom:updated>2026-01-13T16:56:13.725Z</atom:updated>
            <content:encoded><![CDATA[<h3>Automating Business Processes with .NET, Angular, and AI</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XrDfM4ulHa-IQ3UZ8Wsi7A.png" /></figure><p>In many organizations, daily operations still rely heavily on manual processes. Approvals move through email chains, data is copied from one system to another, reports are created by hand, and critical decisions depend on people remembering what to do next.</p><p>These processes work — until they don’t.</p><p>As companies grow, manual workflows become a bottleneck. They slow down operations, increase errors, and prevent teams from focusing on higher-value work. This is where automation becomes not just helpful, but essential.</p><h3>The Real Cost of Manual Processes</h3><p>Manual business processes introduce hidden costs that are often underestimated:</p><ul><li>Delayed approvals and slow response times</li><li>Human errors in repetitive tasks</li><li>Lack of visibility into operational status</li><li>High dependency on specific individuals</li><li>Difficulty scaling operations</li></ul><p>Over time, these inefficiencies directly impact revenue, customer satisfaction, and employee productivity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*08YO-aXc8HqnELiVERz7ug.png" /></figure><h3>What Business Processes Can Be Automated?</h3><p>Many core business operations can be automated with the right architecture and tools, including:</p><ul><li>Invoice and document processing</li><li>Approval workflows for finance, HR, and operations</li><li>Data synchronization between systems (CRM, ERP, internal tools)</li><li>Automated reporting and dashboards</li><li>Customer onboarding and internal requests</li></ul><p>Automation does not mean removing people from the process. It means removing friction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d-VmejJnA6HjMp9FDljeIQ.png" /></figure><h3>Why .NET, Angular, and AI Work So Well Together</h3><p>A modern automation platform typically combines three key elements:</p><p><strong>.NET</strong><br> Provides a secure, scalable backend capable of integrating with databases, APIs, legacy systems, and cloud services. It ensures reliability, performance, and enterprise-grade security.</p><p><strong>Angular</strong><br> Delivers intuitive, responsive user interfaces where teams can manage workflows, approvals, dashboards, and operational tasks efficiently.</p><p><strong>Artificial Intelligence</strong><br> Adds intelligence to automation by interpreting data, classifying documents, detecting patterns, and suggesting actions that previously required human judgment.</p><p>Together, these technologies create systems that don’t just move data, but understand it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vuJs8j9VpgbNREXKuKvdKw.png" /></figure><h3>Business Benefits of Intelligent Automation</h3><p>Companies that automate their processes experience tangible benefits:</p><ul><li>Reduced operational costs</li><li>Faster execution and decision-making</li><li>Fewer errors and rework</li><li>Improved visibility and control</li><li>Teams focused on strategic, high-impact work</li></ul><p>Automation enables organizations to operate consistently, efficiently, and at scale.</p><h3>Final Reflection</h3><p>As organizations navigate increasing complexity, competition, and operational pressure, technology alone is not enough. The real differentiator lies in how effectively companies manage information, processes, and decision-making.</p><p>As <strong>Bill Gates</strong> once said:</p><blockquote><strong><em>“The most meaningful way to differentiate your company from your competition is to do an outstanding job with information.”</em></strong></blockquote><p>In a world driven by automation and artificial intelligence, this insight is more relevant than ever. Companies that combine strong software architecture with intelligent automation are not just optimizing operations — they are building long-term competitive advantage.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25db2e526578" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular, React, and Vue.js]]></title>
            <link>https://medium.com/@rictorres.uyu/angular-react-and-vue-js-76ccefa613d8?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/76ccefa613d8</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[vuejs]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Fri, 19 Dec 2025 15:57:56 GMT</pubDate>
            <atom:updated>2025-12-19T15:57:56.022Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XrJDEv1y1hb-mJlQQAElag.png" /></figure><h3>How Companies Choose Front-End Frameworks Today</h3><p>Over the past months, I conducted a small research based on real-world projects, job postings, and enterprise environments to understand <strong>which front-end frameworks are being used today and why</strong>.</p><p>What I found is that <strong>the choice of framework is rarely about “which one is better”</strong>, and much more about <strong>team structure, business context, and long-term maintainability</strong>.</p><p>Below is a concise comparison based on practical usage.</p><h3>🏢 Angular: Structure for Large Enterprises</h3><p>Angular is widely adopted by <strong>multinational companies and large enterprises</strong>.</p><p><strong>Why?</strong></p><ul><li>Strong, opinionated architecture</li><li>Clear module and dependency injection system</li><li>Excellent support for large, distributed teams</li><li>Well-suited for <strong>micro-frontends</strong> and enterprise-scale applications</li></ul><p><strong>Typical use cases:</strong></p><ul><li>Corporate platforms</li><li>Long-lived applications</li><li>Teams spread across multiple countries</li></ul><p>Angular shines when <strong>consistency, governance, and scalability</strong> are more important than flexibility.</p><h3>🚀 React: Flexibility for Startups and Fast Growth</h3><p>React is heavily used by <strong>startups and fast-moving product teams</strong>.</p><p><strong>Why?</strong></p><ul><li>High flexibility</li><li>Massive ecosystem</li><li>Easy to compose with different libraries (Redux, Zustand, etc.)</li><li>Ideal for rapid experimentation and iteration</li></ul><p><strong>Typical use cases:</strong></p><ul><li>Startups</li><li>MVPs and product-driven teams</li><li>Custom architectures tailored to specific needs</li></ul><p>React works best when teams want <strong>full control over architectural decisions</strong> and move fast.</p><h3>Vue.js: The Bridge for Legacy and Migration Projects</h3><p>Vue.js is commonly chosen when:</p><ul><li>Migrating from <strong>legacy JavaScript</strong></li><li>Replacing <strong>jQuery-based applications</strong></li><li>Gradually modernizing existing systems</li></ul><p><strong>Why?</strong></p><ul><li>Gentle learning curve</li><li>Progressive adoption (can coexist with legacy code)</li><li>Clean syntax that feels familiar to both Angular and React developers</li></ul><p><strong>Typical use cases:</strong></p><ul><li>Legacy modernization</li><li>Teams with high rotation</li><li>Incremental front-end rewrites</li></ul><p>Vue often acts as a <strong>bridge</strong> between structure and flexibility.</p><h3>⚖️ Quick Comparison</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6kZ6axwhVlPwgYqW23uFRA.png" /></figure><h3>🧠 Final Thought</h3><p>Choosing a front-end framework is not a technical fashion decision — <br> it’s a <strong>business and team decision</strong>.</p><p>Understanding <em>why</em> companies choose Angular, React, or Vue helps engineers build solutions that <strong>fit the organization</strong>, not just the codebase.</p><p><strong>If this topic resonates with you, consider following me on Medium.</strong><br> I enjoy exploring how technology choices impact teams, architecture, and long-term maintainability.</p><p>Feel free to share your thoughts or experiences in the comments — I’d love to hear your perspective.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76ccefa613d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automating Inventory Management Across E-commerce and Marketplace Platforms]]></title>
            <link>https://medium.com/@rictorres.uyu/automating-inventory-management-across-e-commerce-and-marketplace-platforms-5c9786a1389f?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c9786a1389f</guid>
            <category><![CDATA[ecommerce]]></category>
            <category><![CDATA[amazon]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Tue, 29 Apr 2025 18:28:35 GMT</pubDate>
            <atom:updated>2025-04-29T18:36:12.258Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PP0yY30zNFoWt9k0UZDO3w.png" /><figcaption>synchronizing inventories</figcaption></figure><p>One of the most powerful applications of the architecture I propose — using <strong>Angular</strong>, <strong>.NET</strong>, and <strong>Azure</strong> — is in automating <strong>inventory management</strong> for businesses that sell across multiple platforms such as their own e-commerce website, <strong>Amazon</strong>, and <strong>Shopify</strong>.</p><p>In a typical scenario, when a product is sold on any platform, it’s critical to <strong>immediately synchronize the inventory</strong> across all sales channels. Otherwise, businesses risk overselling products they no longer have in stock, leading to customer dissatisfaction, penalties, or operational chaos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/1*J9R2uv5bAEFxJTmAapLvAw.png" /></figure><p>With the model I implement:</p><ul><li><strong>Sales events</strong> trigger <strong>Azure Functions</strong> through an event-driven architecture, instantly processing inventory updates.</li><li>The <strong>backend built with .NET</strong> ensures that inventory changes are handled <strong>concurrently and reliably</strong>, even under heavy load.</li><li><strong>Service Bus</strong> and <strong>subscriptions</strong> are used to broadcast inventory updates to all connected systems — whether it’s the local warehouse system, the online store, or third-party marketplaces like Amazon or Shopify.</li><li>If an item’s stock reaches a <strong>predefined minimum threshold</strong>, the system automatically <strong>sends alerts or triggers restocking workflows</strong>, ensuring continuous product availability.</li></ul><p>The combination of <strong>real-time event processing</strong>, <strong>scalable APIs</strong>, and <strong>intelligent notifications</strong> allows businesses to:</p><ul><li><strong>Avoid stockouts</strong> and lost sales opportunities,</li><li><strong>Streamline operations</strong> with minimal human intervention,</li><li><strong>Improve customer satisfaction</strong> through accurate product availability.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R1U063v94hq3gmKIcBiHZA.png" /><figcaption>Finally, we can focus on growing the business instead of chasing inventory updates.</figcaption></figure><p>This is not just automation — it’s <strong>smart, scalable, business-critical automation</strong> designed to keep growing companies competitive in fast-moving markets.</p><p>With the right tools — <strong>Angular</strong>, <strong>.NET</strong>, <strong>Azure</strong>, and a touch of <strong>AI</strong> — automation becomes a powerful asset for any business. From inventory sync to smart workflows, the possibilities are endless.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/585/1*fEDD984GOLPrdTWlTlaPgg.png" /></figure><p><strong>If this inspired you or you’d like help automating your processes, leave a comment or reach out.</strong></p><p>👉 And if you found this helpful, feel free to <strong>subscribe</strong> for more content like this.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c9786a1389f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Choosing Between Newtonsoft.Json and System.Text.Json in .NET Projects]]></title>
            <link>https://medium.com/@rictorres.uyu/choosing-between-newtonsoft-json-and-system-text-json-in-net-projects-0c1abe189891?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c1abe189891</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Thu, 20 Mar 2025 14:46:06 GMT</pubDate>
            <atom:updated>2025-03-20T14:46:06.052Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Choosing Between Newtonsoft.Json and System.Text.Json in .NET Projects</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*Rk87sokW9JPLiGw1LxW_bA.png" /></figure><h3>Introduction</h3><p>When I started a project involving order processing and API communication, I quickly realized the importance of serializing and deserializing JSON data efficiently. While researching my options, I found two main paths:</p><ul><li><strong>Newtonsoft.Json</strong> — a well-established and feature-rich library widely used in the .NET ecosystem.</li><li><strong>System.Text.Json</strong> — a more modern alternative introduced in .NET Core 3.0, promising better performance with lower memory usage.</li></ul><p>The choice between these two libraries can have a significant impact on performance, maintainability, and compatibility. This article will explore their differences, strengths, and weaknesses, with practical C# examples to help you decide which one fits your needs.</p><p>Let me show you a practical example of serializing and deserializing an object using both <strong>Newtonsoft.Json</strong> and <strong>System.Text.Json</strong>.</p><p>Let´s consider that we have a class Persona.</p><pre>public class Persona<br>{<br>    public string Nombre { get; set; }<br>    public int Edad { get; set; }<br>    public DateTime FechaNacimiento { get; set; }<br>}</pre><h3>Serialization</h3><p>Newtonsoft.Json:</p><pre>using Newtonsoft.Json;<br>//...<br>Persona persona = new Persona<br>{<br>    Nombre = &quot;Juan Perez&quot;,<br>    Edad = 30,<br>    FechaNacimiento = new DateTime(1993, 5, 15)<br>};<br>string jsonNewtonsoft = JsonConvert.SerializeObject(persona, Formatting.Indented);<br>Console.WriteLine(&quot;Newtonsoft.Json:&quot;);<br>Console.WriteLine(jsonNewtonsoft);</pre><p>System.Text.Json:</p><pre>using System.Text.Json;<br>//...<br>Persona persona = new Persona<br>{<br>    Nombre = &quot;Juan Perez&quot;,<br>    Edad = 30,<br>    FechaNacimiento = new DateTime(1993, 5, 15)<br>};<br>string jsonSystemText = JsonSerializer.Serialize(persona, new JsonSerializerOptions { WriteIndented = true });<br>Console.WriteLine(&quot;System.Text.Json:&quot;);<br>Console.WriteLine(jsonSystemText);</pre><h3>Deserialización</h3><p>Newtonsoft.Json:</p><pre>using Newtonsoft.Json;<br>//...<br>string json = @&quot;{<br>    &quot;&quot;Nombre&quot;&quot;: &quot;&quot;Juan Perez&quot;&quot;,<br>    &quot;&quot;Edad&quot;&quot;: 30,<br>    &quot;&quot;FechaNacimiento&quot;&quot;: &quot;&quot;1993-05-15T00:00:00&quot;&quot;<br>}&quot;;<br>Persona personaNewtonsoft = JsonConvert.DeserializeObject&lt;Persona&gt;(json);<br>Console.WriteLine(&quot;Newtonsoft.Json Deserializado:&quot;);<br>Console.WriteLine($&quot;Nombre: {personaNewtonsoft.Nombre}, Edad: {personaNewtonsoft.Edad}, Fecha de Nacimiento: {personaNewtonsoft.FechaNacimiento}&quot;);</pre><p>System.Text.Json:</p><pre>using System.Text.Json;<br>//...<br>string json = @&quot;{<br>    &quot;&quot;Nombre&quot;&quot;: &quot;&quot;Juan Perez&quot;&quot;,<br>    &quot;&quot;Edad&quot;&quot;: 30,<br>    &quot;&quot;FechaNacimiento&quot;&quot;: &quot;&quot;1993-05-15T00:00:00&quot;&quot;<br>}&quot;;<br>Persona personaSystemText = JsonSerializer.Deserialize&lt;Persona&gt;(json);<br>Console.WriteLine(&quot;System.Text.Json Deserializado:&quot;);<br>Console.WriteLine($&quot;Nombre: {personaSystemText.Nombre}, Edad: {personaSystemText.Edad}, Fecha de Nacimiento: {personaSystemText.FechaNacimiento}&quot;);</pre><p>We are using the exact number of lines of code, but the performance is better when using System.Text.Json.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/734/1*lV2vXwlaSiR3Kfqoe5QPLQ.gif" /></figure><p>If you are still undecided about which of the two to use, here is a comparative analysis of both libraries.</p><h3>Feature Comparison</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/584/1*2Bhiyup2W8MSuEVV7oxeWQ.png" /></figure><h3>Performance Considerations</h3><p>When performance is a priority, System.Text.Json is the better choice due to its optimized serialization engine. In benchmarks, it outperforms Newtonsoft.Json, especially when dealing with large datasets.</p><p>However, if your project requires advanced features like custom converters, LINQ queries, or compatibility with older .NET versions, Newtonsoft.Json remains the best choice.</p><h3>Conclusion: Which One Should You Choose?</h3><p>So, which one should you go for? It really depends on your needs:</p><ul><li>If you need <strong>better performance and lower memory usage</strong>, and you’re working on <strong>.NET Core 3.0+</strong>, go with <strong>System.Text.Json</strong>.</li><li>If you require <strong>more advanced features like LINQ to JSON, custom converters, or support for older .NET versions</strong>, then <strong>Newtonsoft.Json</strong> is still the way to go.</li></ul><p>Personally, I tend to use <strong>System.Text.Json</strong> when I want a lightweight and fast solution, but I fall back to <strong>Newtonsoft.Json</strong> when I need more flexibility.</p><p>What’s your experience with these libraries? Let me know in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c1abe189891" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Are You Coding Today? The AI Revolution in Software Development]]></title>
            <link>https://medium.com/@rictorres.uyu/how-are-you-coding-today-the-ai-revolution-in-software-development-bca466fd4915?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/bca466fd4915</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[architectural-design]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Thu, 13 Mar 2025 00:32:55 GMT</pubDate>
            <atom:updated>2025-03-13T00:32:55.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M-U-Bt4USJKuukmtZAt6UQ.png" /></figure><p>The world of software development is undergoing a radical transformation with the rise of artificial intelligence. Just a few years ago, developers spent countless hours writing boilerplate code, debugging trivial errors, and optimizing performance. But today, AI-driven tools like GitHub Copilot, ChatGPT, and other AI-powered assistants have reshaped the way we approach programming.</p><h3>The Shift in Focus: From Coding to Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jkvc28IzsSHtdcxpCBR1qw.png" /><figcaption>Engineers focused on Software Architecture</figcaption></figure><p>As AI takes over routine coding tasks, developers are now shifting their efforts toward high-level software architecture and design. The ability to create robust, scalable, and maintainable systems has become more valuable than ever. Instead of manually crafting every line of code, engineers are leveraging AI to generate code snippets, refactor existing solutions, and even write tests, allowing them to focus on:</p><ul><li><strong>System architecture:</strong> Designing well-structured applications that can scale efficiently.</li><li><strong>Code quality and maintainability:</strong> Ensuring best practices, clean coding standards, and long-term sustainability.</li><li><strong>Security and performance optimization:</strong> Addressing vulnerabilities and performance bottlenecks that AI-generated code might overlook.</li><li><strong>Business logic and domain knowledge:</strong> Understanding the problem domain deeply to create solutions that truly add value.</li></ul><h3>The Senior Engineer as a System Designer</h3><p>With experience, senior engineers move beyond writing every line of code and focus on designing entire systems. AI-powered tools now allow them to act as architects, guiding an intelligent team of virtual assistants — backend, frontend, full-stack, and cloud engineers — all working together.</p><p>The key challenge is no longer just coding but ensuring that the AI-assisted development follows best practices and solid architectural principles. To build scalable and maintainable applications, senior engineers must now focus on <strong>solving high-level problems</strong> rather than getting lost in syntax details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/734/1*CxyBBRV8UCewucE7410buw.gif" /></figure><h3>The New Skill Set for Modern Developers</h3><p>In this AI-driven era, the skill set required for software engineers is evolving. Beyond traditional programming skills, developers must now excel in:</p><ul><li><strong>Prompt Engineering:</strong> Knowing how to ask the right questions to AI tools to get the best results.</li><li><strong>Software Architecture &amp; Design Patterns:</strong> Understanding how to structure applications effectively.</li><li><strong>AI Ethics and Bias Awareness:</strong> Ensuring that AI-generated solutions are fair, unbiased, and secure.</li><li><strong>DevOps and Automation:</strong> Integrating AI into CI/CD pipelines for better workflow efficiency.</li></ul><h3>Embracing AI for a Competitive Edge</h3><p>Those who embrace AI as a coding assistant will have a competitive edge in the industry. The future of software development is not about writing every line of code manually but about leveraging AI to build better, faster, and more reliable applications.</p><p>So, the real question is: <strong>How are you coding today?</strong> Are you still following old-school methods, or are you embracing AI to supercharge your development process?</p><p>Let’s discuss — how has AI changed the way you approach programming? How do you integrate AI into your workflow, and what techniques do you use to make the most out of it? Share your thoughts in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bca466fd4915" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Integrate Azure Functions with Service Bus for Order Processing]]></title>
            <link>https://medium.com/@rictorres.uyu/how-to-integrate-azure-functions-with-service-bus-for-order-processing-21bdfbdba1ff?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/21bdfbdba1ff</guid>
            <category><![CDATA[event-driven-architecture]]></category>
            <category><![CDATA[azure-functions]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[ecommerce-web-development]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Wed, 12 Mar 2025 14:48:49 GMT</pubDate>
            <atom:updated>2025-03-12T14:48:49.584Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IbKfzHpUkwn5UomWmHlJ7Q.png" /></figure><h3>Introduction</h3><p>In modern cloud applications, <strong>event-driven architectures</strong> play a crucial role in building <strong>scalable</strong> and <strong>efficient</strong> systems. <strong>Azure Functions</strong> combined with <strong>Azure Service Bus</strong> allow businesses to process messages asynchronously, reducing latency and improving system reliability.</p><p>In this article, we will explore how to use <strong>Azure Functions and Azure Service Bus</strong> to process orders in an <strong>e-commerce</strong> platform. We will cover the key concepts, explain their benefits, and demonstrate how to implement this solution using <strong>C# and .NET</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K58HgtSH_5oEtk0ABg0jYw.png" /><figcaption>online shopping and notifications</figcaption></figure><h3>Key Concepts</h3><h3>2.1 What is Azure Service Bus?</h3><p>Azure Service Bus is a <strong>fully managed message broker</strong> that enables communication between different services using <strong>queues and topics</strong>. It is commonly used for:</p><ul><li><strong>Decoupling services</strong> in distributed applications.</li><li><strong>Reliable message delivery</strong> even if services are temporarily unavailable.</li><li><strong>Load balancing</strong> by processing messages in parallel.</li></ul><h3>2.2 What is Azure Functions?</h3><p>Azure Functions is a <strong>serverless compute service</strong> that allows running event-driven code without managing infrastructure. Functions can be triggered by various sources, including <strong>HTTP requests, timers, and Service Bus messages</strong>.</p><h3>2.3 Why Combine Azure Functions with Service Bus?</h3><p>By integrating Azure Functions with Service Bus, we achieve:</p><p>✅ <strong>Scalability</strong> — Automatically scales based on incoming messages.</p><p>✅ <strong>Asynchronous Processing</strong> — Orders are processed in the background.</p><p>✅ <strong>Reliability</strong> — Ensures message delivery and retries if failures occur.</p><p>✅ <strong>Cost Efficiency</strong> — Only pay for execution time.</p><h3>Implementing in a Real-World E-Commerce Business</h3><h3>Scenario: Processing Customer Orders</h3><p>Imagine an <strong>e-commerce platform</strong> where customers place orders. Once an order is submitted, we need to:</p><p>1️⃣ Send the order to <strong>Azure Service Bus</strong>.</p><p>2️⃣ <strong>Azure Function</strong> listens for new orders.</p><p>3️⃣ Process the order and store it in the database.</p><p>4️⃣ Notify external services (email, CRM, shipping, etc.).</p><h3>Implement the Azure Function</h3><p>Edit ProcessOrderFunction.cs to handle incoming messages:</p><pre>using System;<br>using Microsoft.Azure.WebJobs;<br>using Microsoft.Extensions.Logging;<br><br>namespace ECommerceFunction<br>{<br>    public static class ProcessOrderFunction<br>    {<br>        [FunctionName(&quot;ProcessOrderFunction&quot;)]<br>        public static void Run(<br>            [ServiceBusTrigger(&quot;orders-queue&quot;, Connection = &quot;AzureServiceBusConnection&quot;)] string orderMessage,<br>            ILogger log)<br>        {<br>            log.LogInformation($&quot;📦 New Order Received: {orderMessage}&quot;);<br>            <br>            // Simulate order processing<br>            log.LogInformation(&quot;✅ Order processed successfully.&quot;);<br>        }<br>    }<br>}</pre><h3>Configure Service Bus Connection</h3><p>Edit local.settings.json and add your Service Bus connection string:</p><pre>{<br>  &quot;IsEncrypted&quot;: false,<br>  &quot;Values&quot;: {<br>    &quot;AzureWebJobsStorage&quot;: &quot;UseDevelopmentStorage=true&quot;,<br>    &quot;AzureServiceBusConnection&quot;: &quot;Endpoint=sb://&lt;YOUR_NAMESPACE&gt;.servicebus.windows.net/;SharedAccessKeyName=&lt;KEY_NAME&gt;;SharedAccessKey=&lt;YOUR_KEY&gt;&quot;<br>  }<br>}</pre><p>Replace &lt;YOUR_NAMESPACE&gt;, &lt;KEY_NAME&gt;, and &lt;YOUR_KEY&gt; with your actual <strong>Azure Service Bus</strong> details.</p><h3>Test Locally</h3><p>Run your Azure Function locally with:</p><pre>func start</pre><p>Send a test message to the queue:</p><pre>az servicebus queue send --name orders-queue --namespace-name &lt;YOUR_NAMESPACE&gt; --resource-group &lt;YOUR_RESOURCE_GROUP&gt; --body &#39;{&quot;orderId&quot;:123,&quot;customer&quot;:&quot;John Doe&quot;}&#39;</pre><p>You should see logs indicating that the order was received and processed.</p><h3>Deploy to Azure</h3><p>Deploy your function to Azure with:</p><pre>az functionapp create --resource-group &lt;YOUR_RESOURCE_GROUP&gt; --consumption-plan-location &lt;REGION&gt; --name &lt;FUNCTION_APP_NAME&gt; --storage-account &lt;STORAGE_NAME&gt; --runtime dotnet<br>func azure functionapp publish &lt;FUNCTION_APP_NAME&gt;</pre><p>Your function is now live and ready to process real orders! 🚀</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YOYHYSNhCldPpWX5nNH3QQ.png" /></figure><h3>Conclusion</h3><p>By integrating <strong>Azure Functions</strong> with <strong>Azure Service Bus</strong>, we have created a <strong>scalable</strong>, <strong>event-driven</strong> order processing system for an e-commerce platform. This architecture allows seamless <strong>order handling, database updates, and notifications</strong> while ensuring reliability and performance.</p><p>Azure Functions make it easy to build <strong>serverless applications</strong>, and Service Bus ensures <strong>message durability and fault tolerance</strong>. Whether you’re working on a small project or an enterprise-level application, this combination can help you scale efficiently and improve system resilience.</p><p>💡 <strong>Next Steps</strong>:</p><ul><li>Enhance the function to store orders in a <strong>SQL Server or CosmosDB</strong>.</li><li>Add <strong>email or SMS notifications</strong> upon successful order processing.</li><li>Implement <strong>retry logic</strong> for failed messages.</li></ul><p>Give it a try, and start building your own serverless applications with Azure today! 🚀 If you have any questions, feel free to reach out! 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21bdfbdba1ff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Dead Letter Queue in Azure Service Bus with C#]]></title>
            <link>https://medium.com/@rictorres.uyu/understanding-dead-letter-queue-in-azure-service-bus-with-c-6314902f2aad?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/6314902f2aad</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[azure-service-bus]]></category>
            <category><![CDATA[azure-functions]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Tue, 11 Mar 2025 20:59:18 GMT</pubDate>
            <atom:updated>2025-03-11T20:59:18.865Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*acp7z_B9gIRsu8nxyELmIA.png" /></figure><h3>Introduction</h3><p>In any messaging system, failures are inevitable. Messages can expire, contain errors, or exceed delivery attempts. The <strong>Dead Letter Queue (DLQ)</strong> in Azure Service Bus is crucial for capturing these failed messages, ensuring they are not lost and can be analyzed and reprocessed.</p><p>In this article, we’ll explore how the DLQ works, why it’s essential, and how to handle it in C# with a real-world example.</p><h3>What is a Dead Letter Queue?</h3><p>A Dead Letter Queue (DLQ) is a <strong>subqueue</strong> where messages that cannot be processed successfully are moved. These messages are not lost but instead stored separately so they can be reviewed and handled later.</p><h3>Common Reasons Messages End Up in the Dead Letter Queue:</h3><ul><li><strong>Message Expiration:</strong> If a message stays in the queue longer than its Time-To-Live (TTL) setting.</li><li><strong>Processing Errors:</strong> If a consumer application cannot process the message due to missing data or incorrect format.</li><li><strong>Exceeding Delivery Attempts:</strong> If a message exceeds the maximum number of delivery attempts set in Service Bus.</li></ul><h3>Why is a Dead Letter Queue Important?</h3><ul><li><strong>Ensures No Data is Lost:</strong> Messages that cannot be processed remain available for later review and action.</li><li><strong>Facilitates Debugging and Analysis:</strong> By inspecting DLQ messages, developers can identify common errors and trends in message failures.</li><li><strong>Allows Reprocessing and Recovery:</strong> Messages can be corrected and reprocessed, preventing permanent data loss or system failures.</li><li><strong>Improves System Reliability:</strong> Applications that handle DLQ messages proactively ensure consistent and dependable operations.</li></ul><h3>Real-World Example: Order Processing System</h3><p>Imagine an e-commerce platform that processes customer orders. Orders are sent to an <strong>Order Processing Queue</strong>, where a backend service picks them up and processes them. However, some orders might fail due to incomplete data, such as missing customer details or incorrect payment information.</p><p>Instead of discarding these messages, Azure Service Bus moves them to the <strong>Dead Letter Queue</strong> for later inspection and reprocessing.</p><h3>Handling Dead Letter Queue Messages in C#</h3><h3>Sending Messages to a Queue</h3><p>Before we retrieve messages from the Dead Letter Queue, let’s set up a queue and send messages:</p><pre>var connectionString = &quot;your_service_bus_connection_string&quot;;<br>var queueName = &quot;order-processing-queue&quot;;<br>var client = new QueueClient(connectionString, queueName);<br>var message = new Message(Encoding.UTF8.GetBytes(&quot;OrderID: 12345&quot;));<br>await client.SendAsync(message);</pre><h3>Reading and Handling Dead Letter Messages</h3><p>When an order fails to process, we need a way to retrieve messages from the Dead Letter Queue and take action.</p><pre>var deadLetterQueueName = EntityNameHelper.FormatDeadLetterPath(queueName);<br>var deadLetterClient = new QueueClient(connectionString, deadLetterQueueName);<br><br>var messages = await deadLetterClient.ReceiveAsync(10);<br><br>foreach (var message in messages)<br>{<br>    Console.WriteLine($&quot;Dead Letter Message: {Encoding.UTF8.GetString(message.Body)}&quot;);<br>    <br>    // Take action: Log, alert, or attempt reprocessing<br>    await deadLetterClient.CompleteAsync(message.SystemProperties.LockToken);<br>}</pre><h3>Best Practices for Handling Dead Letter Messages</h3><ul><li><strong>Set Up Alerts:</strong> Use <strong>Azure Monitor</strong> to track when messages accumulate in the DLQ.</li><li><strong>Automate Processing:</strong> Create a scheduled job that checks and retries processing DLQ messages.</li><li><strong>Analyze Failures:</strong> Log message details to diagnose and prevent recurring issues.</li><li><strong>Reprocess or Move Messages:</strong> Develop a strategy to reprocess valid messages or move permanently failed ones to an archive.</li></ul><h3>Conclusion</h3><p>The Dead Letter Queue in Azure Service Bus ensures that problematic messages are not lost but can be analyzed and reprocessed. By properly handling the DLQ, applications become more resilient and maintain high message integrity. Implementing a structured DLQ strategy enhances system reliability, reduces the risk of data loss, and helps teams proactively address recurring issues.</p><p>👉 <strong>Want more Azure and C# insights?</strong> Follow me for more cloud messaging best practices!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6314902f2aad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Azure Service Bus in C#: Understanding Its Purpose and Benefits]]></title>
            <link>https://medium.com/@rictorres.uyu/azure-service-bus-in-c-understanding-its-purpose-and-benefits-601187e56d0b?source=rss-a3be19ac3978------2</link>
            <guid isPermaLink="false">https://medium.com/p/601187e56d0b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[azure-functions]]></category>
            <category><![CDATA[azure-service-bus]]></category>
            <category><![CDATA[c]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Ricardo Torres]]></dc:creator>
            <pubDate>Tue, 11 Mar 2025 20:32:41 GMT</pubDate>
            <atom:updated>2025-03-11T20:32:41.766Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*SAR_N1UyzLORvyGgyN7asw.png" /></figure><h3>Introduction</h3><p>In modern applications, systems do not operate in isolation. For instance, when a travel platform creates an order, this information may need to be sent to other systems such as billing, notifications, or data analytics.</p><p>This is where <strong>Azure Service Bus</strong> comes in — a messaging service that allows applications to communicate <strong>securely, scalably, and reliably</strong>, without requiring direct connections.</p><p>In this article, we will explore what Azure Service Bus is, why it is useful, and how it can be applied to real-world scenarios.</p><h3>What is Azure Service Bus?</h3><p>Azure Service Bus is a cloud-based messaging service that enables different applications and services to exchange information efficiently. It acts as an intermediary that stores messages until the systems that need them can process them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*F6zsmrHURap_1LGBRC9N9g.jpeg" /></figure><h3>Key Features:</h3><ul><li><strong>Asynchronous Messaging:</strong> Enables sending and receiving messages without requiring both systems to be active at the same time.</li><li><strong>Scalability:</strong> Handles large volumes of messages without performance degradation.</li><li><strong>Reliable Delivery:</strong> Ensures messages are delivered even if a system is temporarily down.</li></ul><h3>Use Case: Travel Order Processing</h3><p>Imagine a travel booking application that allows customers to reserve taxi or bus rides. When a new order is created, several actions must take place:</p><ol><li><strong>Store the order in the database.</strong></li><li><strong>Send a notification to the customer</strong> confirming the order.</li><li><strong>Notify the billing system</strong> to generate an invoice.</li><li><strong>Update the vehicle availability system.</strong></li></ol><p>If each of these steps relied on direct service-to-service calls, the system would be difficult to maintain and prone to failures. Instead, by using Azure Service Bus, the order service can simply send a <strong>message to the queue</strong>, and the different systems process it when they are ready.</p><h3>Core Concepts of Azure Service Bus</h3><ol><li><strong>Queues</strong> — Act as a list of messages where a single consumer processes them in the order they arrive (FIFO — First In, First Out).</li><li><strong>Topics and Subscriptions</strong> — Allow sending messages to multiple receivers, which is useful when several systems need the same information.</li></ol><p>For our travel order example, we could use a <strong>Topic</strong> to notify multiple systems simultaneously:</p><ul><li>A <strong>subscription</strong> for the notification service.</li><li>Another <strong>subscription</strong> for the billing system.</li><li>Another for the vehicle availability system.</li></ul><p>This approach <strong>decouples</strong> the systems, allowing each one to process messages at its own pace without dependency on others.</p><h3>Conclusion</h3><p>Azure Service Bus makes inter-application communication easier by ensuring reliable message delivery, even when systems are temporarily unavailable. In the next article, we will explore how to implement a <strong>message producer and consumer in C#</strong> using Azure Service Bus.</p><p>👉 <strong>Interested in more Azure content?</strong> Follow me for more insights on cloud architecture and messaging in C#.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=601187e56d0b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>