Master Salesforce with Manual Testing Online training

 

Master Salesforce with Manual Testing: A Comprehensive Training Guide ☁️🧪

Salesforce is a powerful CRM platform used by businesses worldwide. To ensure its functionality, performance, and reliability, manual testing plays a crucial role. This Salesforce with Manual Testing training program provides a structured approach to mastering Salesforce administration, functional testing, defect management, and Agile methodologies.

Whether you're a beginner or an experienced tester, this guide will help you navigate Salesforce testing with confidence.

Course Overview 📚

This training covers:

• ✅ Salesforce Administration – Understanding the platform's architecture, objects, and automation.

• ✅ Manual Testing Techniques – Writing test cases, executing tests, and managing defects.

• ✅ Agile & Scrum Integration – Aligning testing processes with Agile methodologies.

• ✅ Real-World Tools & Workshops – Hands-on practice with Jira, Workbench, and more.

---

Module 1: Salesforce Administration Overview ⚙️

1.1 Salesforce Basics

• MVC Architecture – Model, View, Controller framework.

• Multi-Tenant Cloud – How Salesforce serves multiple customers securely.

• Salesforce Editions – Enterprise, Professional, Unlimited, Developer, and more.

1.2 Salesforce Services & Clouds ☁️

• SAAS (Salesforce.com) – CRM solutions.

• PAAS (Force.com) – Custom app development.

• Sales Cloud, Service Cloud, Marketing Cloud – Key functionalities.

1.3 User & Data Management

• Profiles, Roles, Permission Sets – Controlling user access.

• Objects & Fields – Standard vs. Custom objects, data types.

• Sandbox Environments – Dev, Partial, Full sandboxes.

1.4 Automation & Reporting

• Workflows, Process Builder, Flows – Automating business processes.

• Reports & Dashboards – Analyzing data effectively.

• SOQL & SOSL – Querying Salesforce data.

---

Module 2: Functional & Manual Testing 🧪

2.1 Testing Fundamentals

• SDLC & STLC – Understanding development and testing lifecycles.

• Testing Levels – Unit, Integration, System, UAT, Regression.

2.2 Test Case Design

• Test Scenarios & Cases – Writing effective test cases.

• Test Techniques – BVA, Equivalence Partitioning, Decision Tables.

• Requirement Traceability Matrix (RTM) – Ensuring test coverage.

2.3 Test Execution

• Manual Testing Best Practices – Executing test cases, logging defects.

• Smoke & Sanity Testing – Quick validation before deep testing.

---

Module 3: Defect Management with Jira/HP ALM 🐞

3.1 Defect Lifecycle

• Bug vs. Defect vs. Error – Key differences.

• Severity & Priority – Classifying defects (Critical, Major, Minor).

3.2 Defect Reporting

• Creating a Defect – Summary, steps to reproduce, attachments.

• Defect States – New, Open, Deferred, Rejected, Closed.

3.3 Special Defects

• Golden Defects – Critical issues requiring immediate attention.

• Latent & Masked Defects – Hidden issues that emerge later.

---

Module 4: Agile & Scrum in Testing 🔄

4.1 Agile Methodology

• User Stories & Sprints – Breaking down requirements.

• Scrum Ceremonies – Standups, Sprint Planning, Retrospectives.

4.2 Agile Metrics

• Velocity & Capacity – Measuring team productivity.

• Burn-down & Burn-up Charts – Tracking progress.

4.3 Waterfall vs. Agile

• When to use each methodology.

Tosca Automation with SAP Training

 

Tosca Automation with SAP Training

Tosca Automation with SAP Training: Course Outline ⚙️SAP

Duration: 30–45 Hours (Live/Online) ⏱️ | Level: Beginner to Advanced 📈 | Certification Prep: Tricentis AS1, AS2, TDS1 🏅

---

Module 1: Introduction to Tosca & SAP Automation (3 Hours) 🚀

• Fundamentals of Automation Testing 🧪
• Role of Tosca in SAP Ecosystems 🌐
• Comparison: Tosca vs. Selenium for SAP (scriptless vs. code-based) 🤖
• Tosca Architecture & Components 🏗️
• Model-Based Risk Coverage, Workspace Setup 📁
• SAP-Specific Challenges ⚠️
• Handling SAP GUI, FIORI, ARIBA, and dynamic controls 💻

Module 2: Environment Setup & Configuration (4 Hours) 🛠️

• Tosca Installation & Activation ✅
• Workspace creation, license configuration 🔑
• SAP GUI Setup 🖥️
• Download, installation, profile configuration ⬇️
• Integration of SAP Modules 🔗
• Connecting Tosca Commander with SAP GUI/FIORI 🌐

Module 3: SAP Object Identification & Modules (6 Hours) 🎯

• XScan for SAP Controls 🔍
• Property-based identification, dynamic ID handling 🆔
• SAP-Specific Modules 🧩
• SAP Toolbar, SAP Statusbar, SAP Menu, SAP Pop-ups ➡️
• Advanced Steering 🕹️
• Table handling, constraints, shadow DOM/iFrame resolution (Salesforce SAP) 📊

Module 4: Test Case Design for SAP (5 Hours) ✍️

• Building SAP Test Cases 🏗️
• Action Modes (Input, Verify, Buffer, WaitOn) 🎬
• Dynamic Data Handling 🔄
• Buffers, expressions (date/time, random data), parameterization 📊
• Recovery & Synchronization ⏳
• Cleanup scenarios, static/dynamic waits for SAP latency ⏲️

Module 5: Advanced SAP Automation (5 Hours) ⚡

• End-to-End SAP Workflows ➡️
• Order-to-cash, invoice validation, data migration testing 💰
• SAP Table & Reporting Automation 📈
• Table scanning, constraint-based validations ✅

Module 6: Frameworks & Best Practices (2 Hours) 📂

• Reusable Components ♻️
• Libraries, business parameters, templates 📄
• Test Data Management (TDM) 🗃️
• Centralized data for SAP modules 📊
• Risk-Based Testing ⚠️
• Prioritizing SAP critical paths 🎯

Module 7: Execution & Reporting (3 Hours) 📊

• SAP Test Orchestration 🎶
• Execution Lists, scheduling, remote agents (DEX) ⚙️
• Customized Reporting 📈
• Dashboard creation, defect logging, result analysis 📝

Module 8: Certification & Job Readiness (3 Hours) 🏅

• Tricentis Certifications 🏆
• AS1 (Automation Specialist), AS2, TDS1 prep 📚
• Resume Building & Interviews 📄
• Top SAP-Tosca interview Q&A (e.g., dynamic ID fixes) 🗣️
• Placement Assistance 🤝
• 100% job guarantee programs (corporate tie-ups) 💼

---

Hands-On Projects 🚧

• SAP Order Processing Automation 🛒
• Automate purchase order creation, validation, and reporting ✅
• SAP FIORI Dashboard Testing 📊
• Dynamic control handling, data-driven validation 📈
• SAP-API Integration Suite 🔗
• Validate data flows between SAP and third-party APIs 🌐

---

Tools & Resources 🧰

• Software: Tosca Commander 16.2+, SAP GUI 7.60+, Postman 💻
• Materials: Real-time SAP demo systems, practice datasets, certification dumps 📚
• Instructors: 9–15 years of SAP automation expertise (e.g., Arjun, Harshiv) 🧑‍🏫

---

Target Audience 🧑‍🎓

• SAP Testers, Manual QA transitioning to automation, Automation Engineers 📈
• Prerequisites: Basic SAP navigation (no coding required) 🗺️

 

What is Playwright In Telugu ప్లేరైట్ కోర్సు: ఏమిటి? ఎవరు నేర్చుకోవచ్చు?...

MuleSoft Demo in Telugu by Mahesh Reddy Batch 09 30 April 2025 8AM

 

 MuleSoft is a software company that provides an integration platform called Anypoint Platform. Think of it as a digital "connector" that helps different software applications, data sources, and devices talk to each other.   

Here's a breakdown of what that means and why it's important:

The Problem MuleSoft Solves:

In today's world, businesses use many different software systems – for customer management (CRM), enterprise resource planning (ERP), marketing, sales, and more. These systems often don't communicate well with each other, leading to:

Data silos: Information is trapped in one system and not accessible to others.   

Inefficient processes: Tasks that could be automated require manual effort to move data between systems.

Poor customer experiences: Lack of integrated data can lead to incomplete or inconsistent information.   

Slow innovation: Connecting new applications and services becomes complex and time-consuming.

What MuleSoft Does:

MuleSoft's Anypoint Platform provides a unified way to connect these disparate systems. It allows businesses to:   

Integrate applications and data: Connect cloud-based applications (like Salesforce, Workday), on-premises systems (legacy databases), and everything in between.   

Build APIs (Application Programming Interfaces): Create reusable building blocks that allow different applications to access specific data or functionality. This is a core concept of MuleSoft's API-led connectivity approach.   

Automate business processes: Design workflows that automatically move data and trigger actions across connected systems.   

Manage and monitor integrations: Provides tools to oversee the health and performance of integrations and APIs.   

Design and test integrations: Offers a user-friendly environment (Anypoint Studio) for developers to build and test their integrations.   

Share and discover reusable assets: Anypoint Exchange acts as a marketplace where organizations can share and reuse connectors, APIs, and templates, accelerating development.   

Key Features of MuleSoft Anypoint Platform:

API-Led Connectivity: This architectural approach organizes integration around reusable APIs (System, Process, and Experience APIs) for better agility and maintainability.   

Anypoint Studio: An Eclipse-based IDE for designing, building, and testing Mule applications.   

Anypoint Exchange: A marketplace for discovering and reusing APIs, connectors, templates, and examples.   

Anypoint Connectors: Pre-built integrations to various popular applications, databases, and technologies, simplifying connectivity.   

DataWeave: A powerful data transformation language for mapping and transforming data between different formats.   

Anypoint Management Center: A web-based interface for managing, monitoring, and securing APIs and integrations.   

CloudHub: MuleSoft's fully managed integration platform as a service (iPaaS) for deploying and scaling integrations in the cloud.   

Runtime Fabric: Allows you to deploy and manage Mule runtimes across various environments, including on-premises, AWS, Azure, and Kubernetes.   

API Manager: For managing the entire API lifecycle, including security, traffic control, and analytics.   

In simple terms, MuleSoft acts as a central nervous system for an organization's digital landscape, enabling different parts of the business to communicate and work together seamlessly, leading to increased efficiency, better decision-making, and enhanced customer experiences.   

MuleSoft was acquired by Salesforce in 2018 and is now a key part of Salesforce's integration and automation offerings.   

Sources and related content

What is MuleSoft in Telugu || MuleSoft Training Course Overview By Venka...

 

What is MuleSoft in Telugu || MuleSoft Training Course Overview By Venkat Who Can Learn MuleSoft

https://youtu.be/FKVj0H-fzRw

#MuleSoftTelugu #MuleSoftTraining #TeluguTutorials #APIIntegration #VenkatMuleSoft #TechTelugu

Integer and Float Variables in Power Automate: Explanation with Examples

 🚀 Integer and Float Variables in Power Automate: Explanation with Examples

In Power Automate, integer and float variables are used to store numerical values. Here's a breakdown of their usage, along with practical flow examples:

1️⃣ Integer Variables

• Purpose: Store whole numbers (e.g., 0, 15, -3).
• Common Actions: Initialize, increment, decrement.
• Example Flow: Counting Email Attachments
  • Scenario: Count the number of attachments in an email.
  • 🔔 Trigger: "When a new email arrives" (Office 365 Outlook).
  • 🧰 Initialize Integer Variable:
    • Name: attachmentCount
    • Type: Integer
    • Value: 0
  • 🔄 Loop Through Attachments:
    • Apply to Each (attachments):
      • 🔢 Increment Variable:
        • Name: attachmentCount
        • Value: 1
  • 📧 Send Result:

    • Send Email:

      Body: "Total attachments: @{variables('attachmentCount')}"
      

2️⃣ Float Variables

• Purpose: Store decimal numbers (e.g., 3.14, -5.67).
• Common Actions: Initialize, update via expressions.
• Example Flow: Calculating Total Order Cost

  • Scenario: Sum the prices of items in a SharePoint list.

  • 🔔 Trigger: "When an item is created" (SharePoint list with items containing a Price column).

  • 🧰 Initialize Float Variable:

    • Name: totalCost
    • Type: Float
    • Value: 0.0

  • 🔄 Loop Through Items:

    • Apply to Each (items):
      • 💰 Set Variable:

        • Name: totalCost

        • Value:

          @add(variables('totalCost'), float(item()?['Price']))
          

  • 📊 Format and Log Result:

    • Update SharePoint:

      Total: @{formatNumber(variables('totalCost'), 'C2')}
      

⚖️ Key Differences & Best Practices

• Aspect | Integer Variables | Float Variables
  • 🧰 Initialization | Initialize variable → Type: Integer | Initialize variable → Type: Float
  • 🛠️ Modification | Increment variable action | Set variable with add(), sub(), etc.
  • 📂 Use Cases | Counting, indexing, loops | Financial calculations, measurements
  • 🧰 Common Functions | add(), sub(), mul(), div() | round(), formatNumber(), float()

➕ Advanced Example: Dynamic Discount Calculation

• Scenario: Apply tiered discounts to an order total.

• 🔔 Trigger: "When a new item is added" (SharePoint list with OrderTotal).

• 🧰 Initialize Variables:

  • OrderTotal (float): @\{triggerBody()?['OrderTotal']}
  • DiscountRate (float): 0.0

• 🤔 Conditional Discounts:

  • If OrderTotal >= 1000:

    @setVariable('DiscountRate', 0.15)
    

  • Else If OrderTotal >= 500:

    @setVariable('DiscountRate', 0.10)
    

• 💰 Calculate Final Price:

  • Set Variable:

    @mul(variables('OrderTotal'), sub(1, variables('DiscountRate')))
    

• 📧 Send Approval:

  • Teams Message:

    "Final Price: @{formatNumber(variables('FinalPrice'), 'C2')}"
    

⚠️ Common Pitfalls & Solutions

• Type Mismatch: Use int() or float() to convert strings/numbers.

  @float(triggerBody()?['PriceString'])
  

• Precision Issues: Use round() to limit decimal places.

  @round(variables('totalCost'), 2)
  

• Incrementing Floats: Manually update using add().

  @add(variables('totalCost'), 2.5)
  

✅ Conclusion

• 🔢 Integers are ideal for counting and discrete values.
• ⚖️ Floats handle precise calculations involving decimals.
• Use Initialize variable, Set variable, and arithmetic functions (add(), mul()) to manage numerical logic effectively.

🏆 By leveraging these variables, you can build dynamic flows for inventory tracking, financial reporting, and more! 🚀

Variable Cascading in power automate with example

 🚀 Variable Cascading in Power Automate with Example

• Variable cascading in Power Automate refers to the sequential use of variables where each subsequent variable's value depends on the previous one.
• This approach allows you to break down complex workflows into manageable steps, enhancing readability and maintainability.
• Below is a practical example demonstrating this concept:

💰 Example: Order Processing Workflow

• Scenario: Automate order processing by validating customer eligibility, calculating discounts, and generating a final invoice. Each step uses variables that depend on prior results.

🪜 Step 1: Trigger and Initialize Variables

* 🔔   **Trigger:** "When a new item is added" to a SharePoint list (e.g., *Orders* list).
* 🧰   **Initialize Variables:**
    * 🆔   CustomerID: Store the customer ID from the trigger.

        ```
        Name: CustomerID
        Type: String
        Value: @{triggerBody()?['CustomerID']}
        ```

    * 💵   OrderTotal: Capture the raw order total.

        ```
        Name: OrderTotal
        Type: Float
        Value: @{triggerBody()?['Amount']}
        ```

🪜 Step 2: Fetch Customer Details

* 🧑‍🤝‍🧑   Get Customer Tier:
    * Use "Get item" (SharePoint) to fetch the customer’s membership tier using *CustomerID*.
* 🗄️   Store the result in a variable:

    ```
    Name: CustomerTier
    Type: String
    Value: @{outputs('Get_Customer_Details')?['body/Tier']}
    ```

🪜 Step 3: Calculate Discount Based on Tier

* 💸   Set Discount Rate:
    * Use a Condition to determine the discount:

        ```
        If CustomerTier = "Gold", set DiscountRate = 0.15
        Else if CustomerTier = "Silver", set DiscountRate = 0.10
        Else, set DiscountRate = 0.05
        ```

* 💰   Initialize Variable:

    ```
    Name: DiscountRate
    Type: Float
    Value: @{body('Condition')}
    ```

🪜 Step 4: Compute Final Amount

* 🧾   Calculate Final Total:
    * Set Variable:

        ```
        Name: FinalAmount
        Type: Float
        Value: @{mul(variables('OrderTotal'), sub(1, variables('DiscountRate'))}
        ```

🪜 Step 5: Generate Invoice

* 📄   Create Invoice:
    * Use "Create file" (OneDrive) to save the invoice with dynamic content:

        ```
        File Name: Invoice_@{variables('CustomerID')}.txt
        Content:
          "Customer: @{variables('CustomerID')}
          Order Total: $@{variables('OrderTotal')}
          Discount: @{mul(variables('DiscountRate'), 100)}%
          Final Amount: $@{variables('FinalAmount')}"
        ```

🔑 Key Points

* **Cascading Dependencies:**
    * CustomerID → Used to fetch CustomerTier.
    * CustomerTier → Determines DiscountRate.
    * DiscountRate + OrderTotal → Compute FinalAmount.
* **Benefits:**
    * 🧩   Modularity: Each step is isolated and reusable.
    * ✅   Clarity: Variables make the flow self-documenting.
    * 🔧   Flexibility: Easily update discount rates or logic without disrupting the entire flow.

🔄 Advanced Use Case: Multi-Level Approvals

* **Scenario:** Escalate approval requests based on dynamic thresholds.
* **Initialize Variables:** ApprovalLevel = 1, MaxApprovalLevel = 3.
* **Loop:** While ApprovalLevel <= MaxApprovalLevel:
    * Send approval to the corresponding team.
    * If rejected, increment ApprovalLevel.
    * If approved, exit loop.

✨ Best Practices

* 🏷️   Descriptive Names: Use clear variable names (e.g., DiscountRate, not var1).
* 🧱   Scope Management: Use Scope actions to group related variables.
* 🚨   Error Handling: Add checks for null/empty variables.

🏆 By cascading variables, you create 🚀 dynamic, adaptable workflows that mirror real-world business logic. This method is particularly useful for financial calculations, approval chains, and data transformations. 🚀

practical use case example of variables in Power Automate

 🚀 Variables in Power Automate: Support Ticket Escalation

Here’s a practical use case example of variables in Power Automate, demonstrating how they solve a real-world business problem and streamline automation:

📞 Scenario: Escalating Support Tickets Based on Priority

• Problem: A company’s IT team wants to automate support ticket escalations. High-priority tickets must:
  • 🧑‍🤝‍🧑 Be assigned to Level 1 support.
  • ⏰ Escalate to Level 2 if unresolved after 2 hours.
  • 📢 Notify the manager if unresolved after 4 hours.
• Variables Used:
  • 🔢 Escalation Level (integer)
  • 📅 Ticket Created Time (string / timestamp)
  • ✅/❌ IsResolved (boolean)
  • 📧 Support Team Emails (array)

🪜 Step-by-Step Flow with Variables

1️⃣ Trigger

* "When a new item is created" (SharePoint list for support tickets).
* Capture ticket details:

    ```
    Priority: High
    Description: Server downtime
    Created Time: 2023-10-05T14:30:00Z
    ```

2️⃣ Initialize Variables

* 🔢 Escalation Level: Track escalation progress.

    ```
    Name: escalationLevel
    Type: Integer
    Value: 1
    ```

* 📅 Ticket Created Time: Store the ticket’s creation timestamp.

    ```
    Name: ticketTime
    Type: String
    Value: @{triggerBody()?['Created']}
    ```

* 📧 Support Team Emails: Define teams to notify.

    ```
    Name: supportEmails
    Type: Array
    Value: ["level1@company.com", "level2@company.com", "manager@company.com"]
    ```

3️⃣ Assign to Level 1 Support

* 📧 Send Email:

    ```
    To: @{variables('supportEmails')[0]}
    Subject: "New High-Priority Ticket: @{triggerBody()?['Title']}"
    Body: "Please resolve within 2 hours. Ticket details: @{triggerBody()?['Description']}"
    ```

4️⃣ Check Resolution Status After 2 Hours

* ⏱️ Delay: Wait 2 hours.

    ```
    Duration: PT2H
    ```

* 🤔 Condition:

    ```
    IsResolved = @{equals(triggerBody()?['Status'], 'Resolved')}
    ```

    * ❌ No (Unresolved):
        * 🔢 Set Variable:

            ```
            Name: escalationLevel
            Value: @{add(variables('escalationLevel'), 1)}
            ```

        * 📧 Send Email to Level 2:

            ```
            To: @{variables('supportEmails')[1]}
            Subject: "Escalated Ticket: @{triggerBody()?['Title']}"
            ```

5️⃣ Escalate to Manager After 4 Hours

* ⏱️ Delay: Wait an additional 2 hours (total 4 hours).
* 🤔 Condition:

    ```
    IsResolved = @{equals(triggerBody()?['Status'], 'Resolved')}
    ```

    * ❌ No (Unresolved):
        * 🔢 Set Variable:

            ```
            Name: escalationLevel
            Value: 3
            ```

        * 💬 Post to Teams:

            ```
            Channel: IT-Managers
            Message: "@{variables('supportEmails')[2]}, urgent ticket unresolved for 4+ hours!"
            ```

⚙️ Variables in Action

• 🔢 Escalation Level: Dynamically tracks the escalation stage (1 → 2 → 3).
• 📅 Ticket Created Time: Ensures accurate delay calculations.
• 📧 Support Team Emails: Centralizes team contacts for easy updates.

✨ Why Variables Matter Here

• 🔄 Dynamic Logic: Escalation level changes based on real-time conditions.
• ♻️ Reusability: Update supportEmails once instead of hardcoding in 3+ actions.
• 🛡️ Error Resilience: Track progress even if the flow fails midway.

➕ Advanced Example: Retry Counter

• Add a retryCounter (integer) variable to handle failed API calls:

  • Initialize: retryCounter = 0.

  • Loop: Retry up to 3 times if an action fails.

  • 🤔 Condition:

    @if(less(variables('retryCounter'), 3), 'Retry', 'Alert Admin')
    

⚠️ Common Pitfalls to Avoid

• 🚫 Uninitialized Variables: Always declare variables before use.
• 📍 Scope Issues: Variables in loops/scopes reset unless explicitly passed.
• 덮어쓰기 Overwriting Data: Use Append to Array instead of Set Variable for lists.

🏆 By using variables strategically, you can build 🔧 flexible, ♻️ maintainable, and 📈 scalable workflows that adapt to dynamic business needs. Let me know if you’d like more examples! 🚀

Introduction to Variables in Power Automate

 🚀 Introduction to Variables in Power Automate

• Variables in Power Automate are containers that store temporary data during a workflow's execution.
• They allow you to 🛠️ manipulate values, ➡️ pass data between steps, and ⚙️ create dynamic logic.
• Unlike traditional programming, variables in Power Automate must be 📍 declared explicitly and are scoped to the entire flow (unless nested in loops or scopes).

🗄️ Types of Variables

Power Automate supports six variable types:

• 🔤 String: Text data (e.g., "Hello, World!").
• 🔢 Integer: Whole numbers (e.g., 42).
• ⚖️ Float: Decimal numbers (e.g., 3.14).
• ✅/❌ Boolean: true or false.
• 📦 Array: Lists of items (e.g., ["Apple", "Banana"]).
• { } Object: Key-value pairs (e.g., {"Name": "John", "Age": 30}).

⚙️ How to Use Variables

1️⃣ Initialize a Variable

• Use the "Initialize variable" action to declare a variable before using it.

• Example:

  Name: customerName
  Type: String
  Value: "John Doe"
  

2️⃣ Modify a Variable

• Update variables using actions like "Set variable", "Increment variable", or "Append to string variable".

📂 Real-World Examples

• 🔤 Example 1: String Variable for Email Personalization

  • Scenario: Send a personalized email using a name extracted from a Microsoft Form response.

  • Trigger: "When a new response is submitted" (Microsoft Forms).

  • Initialize Variable:

    • Name: userName
    • Type: String
    • Value: triggerBody()?['Respondent']

  • Send Email:

    Body: "Hi @{variables('userName')}, thank you for your submission!"
    

• 🔢 Example 2: Integer Variable for Approval Counting

  • Scenario: Track the number of approved requests in a SharePoint list.

  • Initialize Variable:

    • Name: approvalCount
    • Type: Integer
    • Value: 0

  • Loop Through SharePoint Items:

    • For each item where Status = "Approved":

      • Increment Variable:

        Name: approvalCount
        Value: 1
        

  • Post Result to Teams:

    "Total approvals: @{variables('approvalCount')}"
    

• 📦 Example 3: Array Variable for Task Aggregation

  • Scenario: Collect all overdue tasks from a SharePoint list.

  • Initialize Variable:

    • Name: overdueTasks
    • Type: Array
    • Value: [] (empty array)

  • Loop Through Tasks:

    • For each task where DueDate < utcNow():

      • Append to Array Variable:

        Name: overdueTasks
        Value: item()?['Title']
        

  • Send Summary Email:

    Body: "Overdue tasks: @{join(variables('overdueTasks'), ', ')}"
    

• { } Example 4: Object Variable for Data Structuring

  • Scenario: Bundle customer data from multiple sources into a single object.

  • Initialize Variable:

    • Name: customerProfile

    • Type: Object

    • Value:

      JSON

      {
        "Name": "",
        "Email": "",
        "OrderCount": 0
      }
      

  • Update Object:

    • Set Variable:

      Name: customerProfile
      Value: {
        "Name": triggerBody()?['CustomerName'],
        "Email": triggerBody()?['CustomerEmail'],
        "OrderCount": length(triggerBody()?['Orders'])
      }
      

  • Log to SharePoint:

    • Use variables('customerProfile') to save the structured data.

💡 Key Notes

• Scope: Variables are available 📍 after initialization and persist throughout the flow.
• Modification: Use actions like "Set variable" to overwrite values or "Increment variable" for numbers.
• Limitations:
  • Variables cannot be reinitialized.
  • Arrays/objects require manual manipulation (e.g., concatenation or JSON parsing).

✨ Best Practices

• 📍 Declare Early: Initialize variables at the flow’s start for clarity.
• 🏷️ Use Descriptive Names: E.g., invoiceTotal instead of var1.
• 🚫 Avoid Overuse: Rely on dynamic content where possible to simplify flows.

🏆 By mastering variables, you can create 🚀 dynamic, reusable, and efficient workflows in Power Automate!