Author: Alan

  • Automating Email Notifications in SharePoint (Create & Test a Rule)

    In this section, you’ll learn how to create a simple automation rule in SharePoint that sends an email whenever a new item is added to a list. This is especially useful for tracking new customers, support tickets, requests, or any important entries.

    Instead of manually checking your list for updates, SharePoint can automatically notify you. 🚀

    🔔 Why Use Automation Rules?

    Automation rules in SharePoint help you:

    • 📩 Receive instant email notifications
    • ⏳ Reduce manual follow-ups
    • 👀 Stay informed about important changes
    • ⚙️ Turn rules on or off anytime
    • 🛠 Manage rules easily from one place

    In this example, we’ll set up a rule that sends an email whenever a new customer is added to a Customers list.

    Video Explanation


    🛠️ Create an Automation Rule (Item Created)

    Automation rules are created directly from the list where you want the trigger to happen.

    Step-by-Step Instructions

    1. Open your SharePoint list (e.g., Customers).
    2. At the top menu, click Automate.
    3. Select Rules from the dropdown.
    4. Click Create a rule.

    You will see three rule options:

    Rule TypeWhen It Triggers
    🆕 Item CreatedWhen a new item is added
    ✏️ Item ModifiedWhen an existing item is changed
    🗑 Item DeletedWhen an item is removed
    1. Choose Item Created.
    2. Select who should receive the notification (e.g., yourself or another team member).
    3. (Optional) Add a custom message.
    4. Click Create.

    ✅ Your rule is now active.

    You’ll see:

    • A short description of the rule
    • A toggle switch to turn it ON/OFF
    • The ability to manage it later via Automate → Manage Rules

    This gives you full control over your notifications.


    🧪 Test the Automation Rule

    Now that the rule is created, let’s confirm it works.

    Add a New Item

    1. Go to your list.
    2. Click Add New Item.
    3. Fill out all required fields.
    4. Click Save.

    The moment you save the new entry, SharePoint triggers the rule.


    📬 Verify the Email Notification

    1. Open your Outlook (or email client).
    2. Check your inbox.

    You should receive:

    • A notification email
    • Details about the newly created item
    • A link to open the list item directly

    🎉 If the email arrives, your automation is working perfectly.


    🔄 Managing Your Rules Later

    You can always:

    • Edit the rule
    • Disable it temporarily
    • Delete it completely

    To do this:

    • Go to Automate → Manage Rules

    This makes it easy to adjust automation as your workflow evolves.


    ✅ Quick Recap

    • Automation rules help you stay updated automatically
    • You can trigger notifications for created, modified, or deleted items
    • Rules can be enabled, disabled, or edited anytime
    • Testing confirms everything is working as expected

    By using SharePoint automation rules, you make your lists smarter and your workflow more efficient. 🚀

    Send Email Alerts When an Associate Is Assigned in SharePoint

    In this section, you’ll learn how to automatically notify an employee when they are assigned to a customer in a SharePoint list. This is a practical real-world scenario where responsibility changes need to be communicated immediately.

    Instead of manually informing associates when they are assigned to a customer, SharePoint can handle this automatically using built-in automation rules. 🚀

    🎯 Why This Rule Is Useful

    When working with a Customers list, you may have a column called Associate (Person or Group type).

    If someone changes the associate assigned to a customer:

    • 📩 The new associate needs to know immediately
    • ⏳ You avoid delays in task ownership
    • 🔄 Responsibility transitions smoothly
    • 👀 No one misses important assignments

    This rule ensures that whenever the Associate field changes, the new associate receives an automatic email notification.

    Video Explanation


    🛠️ Create a Rule for “Item Modified” (Associate Field Change)

    To notify associates when they are assigned to a customer, we need to create a rule that triggers when the Associate column is modified.

    Step-by-Step Instructions

    1. Open your SharePoint list (e.g., Customers).
    2. Click Automate in the top menu.
    3. Select Rules.
    4. Click Create a rule.
    5. Choose Item Modified.

    You will now configure the condition.


    ⚙️ Configure the Trigger Condition

    After selecting Item Modified, you’ll be asked which column change should trigger the alert.

    1. Select the Associate column from the dropdown.
    2. Set the condition so that the rule triggers when:
      • The Associate value changes (to any new value).

    💡 You do NOT need to specify a particular name.
    The goal is to notify whoever becomes the new associate.


    📩 Configure the Email Notification

    Next, set up who should receive the notification.

    • Choose to notify the Associate column value (the new assigned person).
    • Add a custom message if desired.

    Example custom message:

    “You have been reassigned to this customer.”

    This makes the email clearer and more professional.

    Finally:

    • Click Create.

    ✅ Your rule is now active.


    🧪 Test the Rule

    To confirm everything works:

    1. Open a customer item.
    2. Click Edit.
    3. Change the Associate field to another user.
    4. Click Save.

    Now check the newly assigned associate’s email inbox.

    📬 They should receive:

    • An email notification
    • The name of the customer
    • Your custom message
    • A link to the list item

    If the email arrives, your automation is working perfectly.


    🔍 What This Rule Achieves

    ScenarioResult
    Associate is reassignedNew associate gets notified
    Responsibility changesNo manual follow-up needed
    Customer ownership updatesImmediate awareness

    ✅ Quick Recap

    • Use Item Modified rules for field change notifications
    • Select the Associate column as the trigger
    • Notify the new value (the new associate)
    • Add a custom message for clarity
    • Test by editing the list item

    By using this automation, you ensure that team members are instantly informed when they are assigned new responsibilities — improving accountability and workflow efficiency. 🚀

  • 1 – Azure DevOps Mini-Project

    Table of Contents

    1. Working with Azure DevOps: Create a Project, Import Code, and Set the Default Branch 🚀
    2. Create and Connect to a Linux Virtual Machine in Azure ☁️🐧
    3. 🚀 Setting Up a Self-Hosted Linux Agent for Azure DevOps
    4. 🚀 Azure DevOps Pipeline: Build & Push Docker Image to Azure Container Registry
  • Working with Azure DevOps: Create a Project, Import Code, and Set the Default Branch 🚀

    In this section, we’ll go step-by-step through the very first things you usually do after signing into Azure DevOps:

    These steps are extremely important because they set up the foundation of your DevOps workflow.
    If the project is not organized properly — or the wrong branch is default — pipelines, pull requests, and deployments can behave incorrectly later.

    💡 Key ideas to remember:

    Video Explanation


    1️⃣ Create a Project in Azure DevOps

    Before you can store code or run pipelines, you need a project.

    A project acts as a workspace that contains:

    Think of it as a folder that holds everything related to a single application.

    Steps

    1. Open https://dev.azure.com
    2. Create or select an Organization
    3. Click New Project
    4. Enter:
    5. Set visibility → Private (recommended for learning & security)
    6. Click Create

    After creation, the URL will update to include:

    dev.azure.com/{organization-name}/{project-name}

    📌 At this point your project is empty — no code yet — which we’ll fix in the next step.


    2️⃣ Import a Public GitHub Repository into Azure DevOps 📦

    Instead of starting from scratch, you can import an existing repository.
    Azure DevOps will copy the entire Git history — commits, branches, and files.

    This is useful when:

    Because the repository is public, authentication is not required.

    Steps

    1. Go to Repos (left sidebar)
    2. Click Import repository
    3. Copy the GitHub repository HTTPS URL
    4. Paste the URL into Azure DevOps
    5. Click Import

    ⏳ Azure DevOps now clones the repository internally.

    What gets imported?

    ⚠️ Note:
    Private repositories require authentication (PAT or credentials).
    Public repositories do not.


    3️⃣ Set main as the Default Branch 🌿

    After importing, Azure DevOps automatically picks the default branch alphabetically — not logically.

    That means:

    dev   ← might become default ❌
    main ← what we actually want ✅

    This matters because the default branch is used for:

    If it’s wrong, automation breaks later.

    Steps

    1. Open Repos → Branches
    2. Find the main branch
    3. Click the three dots (⋯) beside it
    4. Select Set as default branch

    You will now see the main branch marked as default.


    ✔️ What You Have Achieved

    TaskPurpose
    Created projectWorkspace for DevOps workflow
    Imported repositoryAdded real application code
    Set default branchEnsures correct CI/CD behavior

    Create and Connect to a Linux Virtual Machine in Azure ☁️🐧

    In this section, we’ll set up a Linux virtual machine inside Azure and connect to it securely using SSH.
    This machine will later act as a self-hosted agent for running DevOps pipelines — meaning builds and deployments will run on your own server instead of Microsoft-hosted agents.

    Before starting, here’s what matters most:

    🔑 Why we create this VM

    🔐 How we connect

    💡 Important: Always keep the downloaded key safe — losing it means losing access to the VM.

    Video Explanation


    1️⃣ Creating a Linux VM in Azure Portal

    We’ll create an Ubuntu server that Azure DevOps can later use as an agent machine.

    A virtual machine automatically comes with supporting resources:

    Azure creates these together so the VM can be accessed over the internet.

    Steps

    1. Open Azure Portal
    2. Click Create a resource → Virtual Machine
    3. Configure the basics:
    SettingExample Value
    Resource GroupCreate new (e.g., Test RG)
    VM NameAny name (e.g., my-vm-azure)
    ImageUbuntu Server 22.04
    Usernameazureuser

    Configure Authentication 🔐

    Azure will download a .pem file — keep it safe!

    This key is your password replacement.


    Networking Setup 🌐

    To allow remote login:

    Without this, connection will fail.


    Create the VM

    1. Review settings
    2. Click Create
    3. Download the private key file (.pem)

    After deployment completes, open the VM resource and note:

    Your Linux machine is now live 🎉


    2️⃣ Connecting to the Linux VM (SSH Login)

    Now we log into the server remotely from your computer.

    You can use:


    Step 1: Go to Key Location

    Open terminal and navigate to the folder containing the .pem file.

    Example:

    cd Downloads

    Step 2: Run SSH Command

    Use this format:

    ssh -i yourkey.pem azureuser@PUBLIC_IP

    Example:

    ssh -i mykey.pem azureuser@20.55.xxx.xxx

    If successful, your prompt changes to:

    azureuser@vm-name:~$

    You are now inside the Azure Linux machine 🖥️


    Fix Permission Error (Very Common ⚠️)

    You may see:

    “Permissions are too open”

    SSH blocks insecure keys.

    Fix (Windows PowerShell)

    Restrict file access so only you can read it.

    Fix Windows SSH key permission:

    icacls <key> /inheritance:r
    icacls <key> /grant:r "$($env:USERNAME):(R)"
    icacls <key> /remove "Authenticated Users" "BUILTIN\Users" "Everyone"
    

    Login:

    ssh -i <key> azureuser@<public-ip>

    After fixing permissions, run the SSH command again.


    ✔️ What You Achieved

    TaskResult
    Created Linux VMCloud server ready
    Generated SSH keySecure authentication
    Opened port 22Remote connectivity
    Logged into VMReady for DevOps agent setup

    You now have your own cloud machine ready to install tools and run CI/CD pipelines 🚀

    🚀 Setting Up a Self-Hosted Linux Agent for Azure DevOps

    In this section, we’ll configure a Linux Virtual Machine (VM) to act as a self-hosted agent for Azure DevOps pipelines. Instead of using Microsoft-hosted agents, your own VM will execute pipeline jobs — giving you more control, flexibility, and customization options.

    Here’s what we’ll cover:

    Video Explanation

    By the end of this section, your Linux VM will be fully ready to execute CI/CD pipeline jobs 🎯


    🐳 Install and Configure Docker

    Docker is commonly required in DevOps pipelines, especially for container-based builds and deployments.

    Since we are logged in as azureuser, we must grant this user permission to run Docker commands without sudo.

    🔹 Grant Docker Permissions

    Run:

    sudo usermod -aG docker azureuser

    This adds the user to the Docker group.

    🔄 Restart Docker Service

    sudo systemctl restart docker

    Restarting ensures permission changes take effect.

    🚪 Log Out and Log Back In

    Exit the VM session:

    exit

    Then reconnect using your SSH command. This refreshes group membership.

    ✅ Verify Docker Installation

    To confirm everything works correctly, pull the hello-world image:

    docker pull hello-world

    If the image downloads successfully:

    Your Docker setup is now complete 🎉


    🧰 Install Additional Utilities (If Required)

    Because this is a self-hosted VM, we are responsible for maintaining it.

    Pipelines may require additional tools such as:

    Even if your current project doesn’t require them, it’s important to understand that future pipelines might.

    📦 Example: Install unzip

    sudo apt install unzip -y

    💡 Tip: Only install what your pipeline needs. Self-hosted agents provide flexibility — but also require proper maintenance.


    🔗 Connect the Linux VM to Azure DevOps

    Now we’ll connect the VM so that it can execute pipeline jobs from:

    This involves generating a Personal Access Token and configuring the VM as an agent.


    🔐 Generate a Personal Access Token (PAT)

    The PAT allows secure communication between Azure DevOps and your VM.

    Steps:

    1. Go to your Azure DevOps organization.
    2. Click User Settings (top-right).
    3. Select Personal Access Tokens.
    4. Click New Token.

    Configure:

    ⚠ In production, always follow the Principle of Least Privilege.


    🏗 Create an Agent Pool

    Next, create a pool where your VM agent will be registered.

    1. Go to Organization Settings.
    2. Select Agent Pools.
    3. Click Add Pool.
    4. Choose Self-hosted.
    5. Provide a meaningful name (e.g., My Agent Pool).
    6. Allow access to all pipelines if required.
    7. Click Create.

    Your agent pool is now ready — but currently empty.


    💻 Configure the Linux VM as an Agent

    From the Agent Pool page:

    1. Open your pool.
    2. Click New Agent.
    3. Select the Linux tab.
    4. Follow the provided instructions.

    Now switch to your Linux VM.

    📁 Create a Working Directory

    mkdir myagent
    cd myagent

    Verify:

    ls

    📥 Download the Agent Package

    Run the wget command shown in the Azure DevOps portal:

    wget <agent-download-url>

    Confirm the file exists:

    ls

    You should see a .tar.gz file.

    📦 Extract the Package

    tar zxvf <agent-file-name>.tar.gz

    After extraction, you should see files including:


    ⚙ Configure the Agent

    Run:

    ./config.sh

    Follow the prompts:

    If successful, the configuration will complete and return you to the terminal.


    ▶ Start the Agent

    Run:

    ./run.sh

    If successful, you will see:

    Listening for Jobs

    Now return to:

    Organization Settings → Agent Pools → My Agent Pool

    You should see:

    Your self-hosted Linux VM is now fully connected and ready to execute Azure DevOps pipeline jobs 🚀


    🎯 Section Summary

    In this section, we:

    Your environment is now prepared to run CI/CD pipelines using your own infrastructure — giving you greater flexibility and control over your DevOps workflows.

    🚀 Azure DevOps Pipeline: Build & Push Docker Image to Azure Container Registry

    In this section, we’ll walk through the complete setup required to build and push a Docker image using Azure DevOps.

    This includes:

    By the end, you’ll clearly understand how the pipeline builds your Docker image and pushes it securely to Azure.

    Video Explanation


    📦 1️⃣ Create Azure Container Registry (ACR)

    Before a pipeline can push an image, we need a registry to store it.

    We create this inside:

    🛠 Steps

    1. Go to the Azure Portal.
    2. Search for Container Registries.
    3. Click Create.
    4. Select:
    5. Provide a unique registry name.
    6. Keep default settings (Basic SKU is fine).
    7. Click Review + Create → Create.

    After deployment:

    At this point, it will be empty.
    Our pipeline will push images here.


    🔧 2️⃣ Create a New Pipeline in Azure DevOps

    Now we configure automation in:

    🛠 Steps

    1. Go to Pipelines → Create Pipeline.
    2. Select Azure Repos Git.
    3. Choose your repository.
    4. Select the template:
      Docker: Build and Push an image to Azure Container Registry

    During setup, Azure DevOps will ask for:

    It will also create or use a service connection so DevOps can securely authenticate with Azure.


    📁 3️⃣ Understand the Repository Structure

    Before analyzing the pipeline, we need to understand the project structure.

    In the repository root, we have three microservices:

    Each microservice:

    In this section, we are working with the Result microservice.


    ⚙️ Full Pipeline YAML Explained

    Below is the pipeline we configured:

    trigger:
    paths:
    include:
    - result/*resources:
    - repo: selfvariables:
    dockerRegistryServiceConnection: 'bc565285-3a3d-4b9b-b39e-52859b47c3ec'
    imageRepository: 'resultapp'
    containerRegistry: 'myACRForCiCd2.azurecr.io'
    dockerfilePath: '$(Build.SourcesDirectory)/result/Dockerfile'
    tag: '$(Build.BuildId)'pool:
    name: 'myagentpool'stages:
    - stage: Build
    displayName: Build stage
    jobs:
    - job: Build
    displayName: Build
    steps:
    - task: Docker@2
    displayName: Build image
    inputs:
    containerRegistry: '$(dockerRegistryServiceConnection)'
    repository: '$(imageRepository)'
    command: 'build'
    Dockerfile: 'result/Dockerfile'
    tags: '$(tag)'- stage: Push
    displayName: Push stage
    jobs:
    - job: Push
    displayName: Push
    steps:
    - task: Docker@2
    displayName: Push image
    inputs:
    containerRegistry: '$(dockerRegistryServiceConnection)'
    repository: '$(imageRepository)'
    command: 'push'
    Dockerfile: 'result/Dockerfile'
    tags: '$(tag)'

    Let’s break it down.


    🔁 Trigger Section

    trigger:
    paths:
    include:
    - result/*

    This means:

    ✅ The pipeline runs only when changes are made inside the result folder.

    It prevents unnecessary builds when other microservices change.


    📦 Resources Section

    resources:
    - repo: self

    self refers to the current repository.
    This is the default behavior.


    🧠 Variables Section

    Instead of hardcoding values inside tasks, we defined reusable variables:

    VariablePurpose
    dockerRegistryServiceConnectionAuthenticates to Azure
    imageRepositoryName of image in ACR
    dockerfilePathLocation of Dockerfile
    tagUnique image version

    We use:

    tag: $(Build.BuildId)

    Build.BuildId is a system-generated variable that uniquely identifies the pipeline run.

    Each build gets a unique Docker image tag.


    🖥 Pool Section

    pool:
    name: myagentpool

    This defines where the pipeline runs.

    Both stages use the same self-hosted agent pool.

    This is important because Docker images are stored locally on the agent machine.


    🏗 Build Stage

    Structure:

    Stage → Job → Task

    The Build stage:

    What it does:

    👉 Builds the Docker image using result/Dockerfile
    👉 Tags it using $(Build.BuildId)

    The image is created locally on the agent machine.


    🚀 Push Stage

    The Push stage:

    What it does:

    👉 Pushes the Docker image to Azure Container Registry
    👉 Uses the same image name and tag


    🔗 How Build and Push Work Together

    There is no automatic transfer of images between stages.

    Here’s what actually happens:

    1️⃣ Build stage creates the image locally
    2️⃣ Image is tagged using Build ID
    3️⃣ Push stage runs on the same agent
    4️⃣ Push stage pushes that image to ACR

    The connection works because:

    If the stages ran on different agents, the push would fail because the image would not exist there.


    📌 Complete Workflow Summary

    Here’s the full flow:

    1️⃣ Developer commits code in result folder
    2️⃣ Pipeline triggers automatically
    3️⃣ Build stage creates Docker image
    4️⃣ Image is tagged uniquely
    5️⃣ Push stage uploads image to ACR
    6️⃣ Image appears under ACR → Repositories


    🎯 What This Pipeline Achieves

    In this section, we:

    This setup forms the foundation of a container-based CI pipeline in Azure DevOps.

  • 14 – HCP Terraform (Terraform Cloud) Explained — Remote Execution, Authentication, and Workspaces

    Most Terraform users begin with a simple workflow:

    terraform init
    terraform plan
    terraform apply
    

    Everything runs locally, credentials come from the local machine, and the state file is stored either locally or in a configured backend.

    However, real-world teams rarely run Terraform from developer laptops.
    Infrastructure provisioning is executed from a controlled environment — this is where HCP Terraform (Terraform Cloud) comes in.

    This article explains how Terraform Cloud works, what actually changes compared to local execution, and how to correctly authenticate and run Terraform remotely.

    Table of Contents

    1. What Terraform Cloud Actually Changes
    2. Key Architectural Difference
    3. Creating the Organization and Workspace
    4. Connecting Local Terraform to Terraform Cloud
    5. First Remote Plan and Why It Fails
    6. Why Local Credentials Stop Working
    7. Azure Authentication in Terraform Cloud
    8. Adding Credentials to the Workspace
    9. Running Terraform Remotely
    10. Verifying Remote State
    11. Understanding Workspaces
    12. What Terraform Cloud Provides Beyond CLI
    13. Practical Takeaway

    What Terraform Cloud Actually Changes

    Terraform Cloud does not replace the Terraform CLI — it replaces the execution environment.

    Instead of:

    Local CLI → Cloud Provider API
    

    the architecture becomes:

    Local CLI → Terraform Cloud → Cloud Provider API
    

    Your machine only submits configuration and receives logs.
    The actual Terraform runtime, state, and authentication live in Terraform Cloud.


    Key Architectural Difference

    ComponentLocal TerraformTerraform Cloud
    ExecutionRuns on developer machineRuns on HashiCorp infrastructure
    StateLocal or backend-configuredAlways remote
    AuthenticationLocal credentialsWorkspace credentials
    Audit HistoryLimitedBuilt-in
    CollaborationManualNative support

    Understanding this distinction is essential — most confusion with Terraform Cloud comes from assuming it behaves like a remote backend only.
    It is actually remote execution, not just remote storage.


    Creating the Organization and Workspace

    After signing into:

    https://app.terraform.io
    

    Create an organization and then create a workspace using:

    CLI-Driven Workflow

    This workspace acts as an isolated remote Terraform runtime.

    Each workspace has:

    • Its own state file
    • Its own variables
    • Its own credentials
    • Its own run history

    Think of it as a remote Terraform working directory.


    Connecting Local Terraform to Terraform Cloud

    Create a minimal configuration:

    terraform {
      cloud {
        organization = "my-organization"
    
        workspaces {
          name = "cli-lab"
        }
      }
    }
    
    provider "azurerm" {
      features {}
    }
    
    resource "azurerm_resource_group" "example" {
      name     = "rg-hcp-demo"
      location = "eastus"
    }
    

    Initialize:

    terraform init
    

    Terraform will request authentication with Terraform Cloud.

    Run:

    terraform login
    

    This generates an API token and stores it locally in:

    ~/.terraform.d/credentials.tfrc.json
    

    At this point, your CLI is authenticated with Terraform Cloud — not with Azure.


    First Remote Plan and Why It Fails

    Running:

    terraform plan
    

    will fail with an authentication error for Azure.

    This often surprises users who already have working local credentials such as:

    $env:ARM_CLIENT_ID="..."
    $env:ARM_CLIENT_SECRET="..."
    $env:ARM_SUBSCRIPTION_ID="..."
    $env:ARM_TENANT_ID="..."
    

    These variables work locally because Terraform executes on your machine.

    Terraform Cloud cannot access them.


    Why Local Credentials Stop Working

    In local execution:

    Terraform (local process) reads environment variables → authenticates to Azure
    

    In Terraform Cloud:

    Terraform Cloud runtime reads workspace variables → authenticates to Azure
    

    The execution environment changed, therefore the authentication location must also change.


    Azure Authentication in Terraform Cloud

    Terraform Cloud must authenticate independently using a Service Principal.

    Create one if necessary:

    az ad sp create-for-rbac --role Contributor --scopes /subscriptions/<SUBSCRIPTION_ID>
    

    Azure returns:

    appId        → Client ID
    password     → Client Secret
    tenant       → Tenant ID
    subscription → Subscription ID
    

    Adding Credentials to the Workspace

    In the workspace → Variables → Environment Variables

    Add:

    VariableDescription
    ARM_CLIENT_IDService Principal App ID
    ARM_CLIENT_SECRETService Principal Secret
    ARM_TENANT_IDAzure Tenant
    ARM_SUBSCRIPTION_IDAzure Subscription

    Mark secrets as sensitive.

    These variables now exist inside the remote execution environment.


    Running Terraform Remotely

    Run:

    terraform plan
    

    You will notice:

    • The command returns output locally
    • Execution logs appear in the Terraform Cloud UI
    • The plan runs remotely

    Then apply:

    terraform apply
    

    The resource is created in Azure by Terraform Cloud — not by your machine.


    Verifying Remote State

    Delete local Terraform metadata:

    rm -r .terraform
    

    Run again:

    terraform plan
    

    It still works.

    This confirms:

    State is stored in Terraform Cloud, not locally.


    Understanding Workspaces

    A workspace represents an isolated Terraform environment.

    Each workspace maintains:

    • Independent state
    • Independent credentials
    • Independent variables
    • Independent run history

    This enables environment separation:

    WorkspacePurpose
    devDevelopment infrastructure
    testValidation environment
    prodProduction infrastructure

    No duplication of directories or backend configuration required.


    What Terraform Cloud Provides Beyond CLI

    Terraform Cloud effectively acts as Terraform’s native CI/CD system.

    It adds:

    • Remote execution
    • State management
    • Secrets management
    • Run history
    • Access control
    • Collaboration
    • Policy enforcement (in higher tiers)

    Without external pipelines.


    Practical Takeaway

    Terraform Cloud is not just a UI layer or remote backend.

    It changes the operational model:

    From:

    Developers provisioning infrastructure

    To:

    Controlled platform provisioning infrastructure

    The CLI becomes a client — not the executor.

    Understanding this distinction is fundamental before using VCS-driven workflows, automated applies, or multi-environment deployments.

  • 13 – How to Import Existing Azure Resources into Terraform (Step-by-Step Mini Project)

    When learning Terraform, most tutorials start by creating new infrastructure.

    But in the real world, companies already have infrastructure running in the cloud — and your job is to bring it under Terraform management without recreating or breaking anything.

    That process is called:

    Terraform Import

    In this mini project we will:

    • Create Azure infrastructure manually (outside Terraform)
    • Make Terraform “discover” it
    • Connect Terraform state to real resources
    • Understand what Terraform actually manages

    This tutorial focuses on understanding — not best practices, modules, or clean architecture.

    Table of Contents

    1. Step 0 — Create Infrastructure in Azure (Without Terraform)
    2. Create Resource Group
    3. Create Virtual Network and Subnet
    4. Create App Service Plan (Free Tier)
    5. Create Web App
    6. Final Verification
    7. Step 1 — Terraform Tries to Recreate Existing Resources
    8. Step 2 — Connect Terraform to the Real Azure Resource
    9. Verify Terraform Learned the Resource
    10. The Most Important Test
    11. What Just Happened?
    12. Repeat for Other Resources
    13. Key Concept You Must Understand
    14. Final Result
    15. What You Learned

    Step 0 — Create Infrastructure in Azure (Without Terraform)

    We first create resources using Azure CLI so Terraform has no knowledge of them.

    Resource Names

    ResourceName
    Resource Grouprgcliminipro21212
    Virtual Networkvnetcliminipro21212
    App Service Planplancliminipro21212
    Web Appwebappcliminipro21212
    Regioncentralus

    Create Resource Group

    az group create --name rgcliminipro21212 --location centralus
    

    Verify:

    az group show --name rgcliminipro21212 --query "{Name:name,Location:location}"
    

    Create Virtual Network and Subnet

    az network vnet create --resource-group rgcliminipro21212 --name vnetcliminipro21212 --address-prefix 10.0.0.0/16 --subnet-name default --subnet-prefix 10.0.1.0/24
    

    Verify VNet:

    az network vnet show --resource-group rgcliminipro21212 --name vnetcliminipro21212 --query addressSpace.addressPrefixes
    

    Verify Subnet:

    az network vnet subnet show --resource-group rgcliminipro21212 --vnet-name vnetcliminipro21212 --name default --query addressPrefix
    

    Create App Service Plan (Free Tier)

    az appservice plan create --name plancliminipro21212 --resource-group rgcliminipro21212 --sku F1 --is-linux
    

    Verify:

    az appservice plan show --name plancliminipro21212 --resource-group rgcliminipro21212 --query "{Tier:sku.tier,Name:sku.name}"
    

    Create Web App

    az webapp create --resource-group rgcliminipro21212 --plan plancliminipro21212 --name webappcliminipro21212 --runtime "NODE:18-lts"
    

    Verify:

    az webapp show --resource-group rgcliminipro21212 --name webappcliminipro21212 --query "{State:state,Host:defaultHostName}"
    

    Final Verification

    az resource list --resource-group rgcliminipro21212 --output table
    

    At this point:

    Infrastructure exists in Azure
    Terraform knows nothing about it


    Step 1 — Terraform Tries to Recreate Existing Resources

    Create a file rg.tf

    resource "azurerm_resource_group" "rg" {
      name     = "rgcliminipro21212"
      location = "centralus"
    }
    

    Run:

    terraform plan
    

    You will see:

    Plan: 1 to add
    

    Why?

    Because Terraform has no memory yet — it only trusts the state file, not Azure.


    Step 2 — Connect Terraform to the Real Azure Resource

    We now map the Terraform resource to the real resource.

    Get Resource ID

    az group show --name rgcliminipro21212 --query id --output tsv
    

    Output looks like:

    /subscriptions/<sub-id>/resourceGroups/rgcliminipro21212
    

    Import into Terraform

    terraform import azurerm_resource_group.rg <RESOURCE_ID>
    

    Verify Terraform Learned the Resource

    Check state

    terraform state list
    

    Inspect resource details

    terraform state show azurerm_resource_group.rg
    

    Terraform downloaded the real configuration from Azure.


    The Most Important Test

    Run:

    terraform plan
    

    Now you should see:

    No changes. Infrastructure matches configuration.
    

    What Just Happened?

    Before import:

    TerraformAzure
    Wants to create RGRG already exists

    After import:

    TerraformAzure
    Knows RG existsRG exists

    Terraform did not create anything.
    It only learned reality.


    Repeat for Other Resources

    You repeat the same process for:

    • Virtual Network
    • Subnet
    • App Service Plan
    • Web App

    The pattern never changes:

    1. Write resource block
    2. terraform plan → shows create
    3. terraform import
    4. terraform plan → shows no changes

    You are teaching Terraform what already exists.


    Key Concept You Must Understand

    Terraform does NOT manage infrastructure.

    Terraform manages a state file.

    If it is not in state → Terraform thinks it does not exist
    If it is in state → Terraform controls it


    Final Result

    After importing all resources:

    You can now run:

    terraform destroy
    

    And Terraform will delete resources that were originally created manually.

    That proves:

    Terraform now owns the infrastructure


    What You Learned

    • Terraform does not read Azure automatically
    • Import does not create resources
    • State file is the brain of Terraform
    • Infrastructure can be adopted safely

    This is one of the most important real-world Terraform skills.


    If you understood this concept, you now understand more Terraform than most beginners who only follow terraform apply tutorials.

  • 12 – Setup Azure Monitoring And Alerting With Terraform (Hands-On Mini Project)

    In this mini project we will build a real Azure VM → deploy a website → monitor it → get email alerts when something goes wrong — all using Terraform.

    This is not just copy-paste infrastructure.
    We will understand why each piece exists and what Azure is actually doing behind the scenes.

    By the end you will know:

    • How Azure Monitor actually works 🧠
    • Difference between resource, metric, and action
    • How alerts really get triggered
    • How to simulate failures (CPU stress testing 🔥)

    Table of Contents

    1. Architecture Overview
    2. Step 1 — Networking Infrastructure
    3. Step 2 — Create the Virtual Machine
    4. Step 3 — Deploy Website Automatically (Remote-Exec)
    5. Step 4 — Create Notification Channel (Action Group)
    6. Step 5 — CPU Alert (High Usage)
    7. Step 6 — Memory Alert
    8. ⚠️ Important Learning (Real-World Insight)
    9. Final Result
    10. What You Learned
    11. Final Thoughts

    Architecture Overview

    We will build:

    ComponentPurpose
    Resource GroupContainer for everything
    VNet + SubnetNetwork for VM
    NSGFirewall rules
    Public IPInternet access
    Linux VMRuns website
    NginxSample application
    Action GroupNotification channel
    Metric AlertsDetect problems

    Flow:

    Problem happens → Azure detects metric → Alert rule triggers → Action group emails you 📧


    Step 1 — Networking Infrastructure

    We first create the foundation: network + firewall + IP + NIC

    Resource Group

    resource "azurerm_resource_group" "rg" {
      name     = "rgminipro090212"
      location = "Central US"
    }
    

    Virtual Network & Subnet

    resource "azurerm_virtual_network" "vnet" {
      name                = "vnetminipro12212"
      address_space       = ["10.0.0.0/16"]
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    }
    
    resource "azurerm_subnet" "subnet" {
      name                 = "subnetminipro12100339"
      resource_group_name  = azurerm_resource_group.rg.name
      virtual_network_name = azurerm_virtual_network.vnet.name
      address_prefixes     = ["10.0.2.0/24"]
    }
    

    Network Security Group (Firewall)

    We allow:

    • SSH (22) → remote login
    • HTTP (80) → website access
    resource "azurerm_network_security_group" "nsg" {
      name                = "nsgminipro98922"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      security_rule {
        name                       = "SSH"
        priority                   = 100
        direction                  = "Inbound"
        access                     = "Allow"
        protocol                   = "Tcp"
        source_port_range          = "*"
        destination_port_range     = "22"
        source_address_prefix      = "*"
        destination_address_prefix = "*"
      }
    
      security_rule {
        name                       = "HTTP"
        priority                   = 110
        direction                  = "Inbound"
        access                     = "Allow"
        protocol                   = "Tcp"
        source_port_range          = "*"
        destination_port_range     = "80"
        source_address_prefix      = "*"
        destination_address_prefix = "*"
      }
    }
    

    Public IP + Network Interface

    resource "azurerm_public_ip" "pip" {
      name                = "pipminipro1212909"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
      allocation_method   = "Static"
    }
    
    resource "azurerm_network_interface" "nic" {
      name                = "nicminipro90909111"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      ip_configuration {
        name                          = "internal"
        subnet_id                     = azurerm_subnet.subnet.id
        private_ip_address_allocation = "Dynamic"
        public_ip_address_id          = azurerm_public_ip.pip.id
      }
    }
    
    resource "azurerm_network_interface_security_group_association" "assoc" {
      network_interface_id      = azurerm_network_interface.nic.id
      network_security_group_id = azurerm_network_security_group.nsg.id
    }
    

    ❓ Important Concept — Where is NSG applied?

    You attached NSG to NIC, not subnet.

    How to verify in portal:

    Where to checkWhat you see
    NIC → NetworkingNSG attached
    NSG → SubnetsEmpty

    Why?

    Azure firewall works at 2 levels:

    LevelScope
    Subnet NSGApplies to all VMs
    NIC NSGApplies to single VM

    We used NIC because this project has only one VM.


    Step 2 — Create the Virtual Machine

    resource "azurerm_linux_virtual_machine" "vm" {
      name                = "vmminipro343900"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
      size                = "Standard_D2s_v3"
      network_interface_ids = [azurerm_network_interface.nic.id]
    
      admin_username = "azureuser"
    
      admin_ssh_key {
        username   = "azureuser"
        public_key = file("C:/Alan/MyWork/linuxvms/mykeys/key1.pub")
      }
    
      os_disk {
        caching              = "ReadWrite"
        storage_account_type = "Standard_LRS"
      }
    
      source_image_reference {
        publisher = "Canonical"
        offer     = "UbuntuServer"
        sku       = "18.04-LTS"
        version   = "latest"
      }
    }
    

    SSH Into the VM

    Fix Windows SSH key permission:

    icacls <key> /inheritance:r
    icacls <key> /grant:r "$($env:USERNAME):(R)"
    icacls <key> /remove "Authenticated Users" "BUILTIN\Users" "Everyone"
    

    Login:

    ssh -i <key> azureuser@<public-ip>
    

    ✔ VM verified working


    Step 3 — Deploy Website Automatically (Remote-Exec)

    Now Terraform becomes powerful 💥
    We configure the server automatically.

    provisioner "remote-exec" {
    
      inline = [
    
        "echo waiting for cloud-init...",
        "while [ ! -f /var/lib/cloud/instance/boot-finished ]; do sleep 2; done",
    
        "sudo apt-get update -y",
        "sudo apt-get install -y nginx",
    
        "echo '<h1>Terraform Monitoring Lab Working</h1>' | sudo tee /var/www/html/index.html",
    
        "sudo systemctl restart nginx",
        "sudo systemctl enable nginx"
      ]
    
      connection {
          type        = "ssh"
          user        = "azureuser"
          private_key = file("C:/Alan/MyWork/linuxvms/mykeys/key1")
          host        = azurerm_public_ip.pip.ip_address
      }
    }
    

    ⚠️ Important learning:

    Provisioners run only during resource creation
    So we had to destroy and apply again

    Now open browser:

    http://<public-ip>
    

    Website works 🎉


    Step 4 — Create Notification Channel (Action Group)

    We tell Azure:

    When something breaks → email me

    resource "azurerm_monitor_action_group" "ag" {
      name                = "agminipro9090"
      resource_group_name = azurerm_resource_group.rg.name
      short_name          = "alerts"
    
      email_receiver {
        name          = "sendtoadmin"
        email_address = "alankseb@gmail.com"
      }
    }
    

    Verify in portal:

    Azure Monitor → Alerts → Action Groups


    Step 5 — CPU Alert (High Usage)

    Now we create the actual monitoring rule.

    resource "azurerm_monitor_metric_alert" "cpu_alert" {
      name                = "highcpualertminipro990922"
      resource_group_name = azurerm_resource_group.rg.name
      scopes              = [azurerm_linux_virtual_machine.vm.id]
      description         = "Alert when CPU usage is greater than 60%"
    
      criteria {
        metric_namespace = "Microsoft.Compute/virtualMachines"
        metric_name      = "Percentage CPU"
        aggregation      = "Average"
        operator         = "GreaterThan"
        threshold        = 60
      }
    
      action {
        action_group_id = azurerm_monitor_action_group.ag.id
      }
    }
    

    Test the Alert 🔥

    SSH into VM:

    sudo apt-get install stress -y
    stress --cpu 6 --timeout 300
    

    Wait 5 minutes…

    📧 You receive email:

    Azure Monitor alert triggered

    Congratulations — you built real monitoring.


    Step 6 — Memory Alert

    We add another rule:

    resource "azurerm_monitor_metric_alert" "disk_alert" {
      name                = "lowdiskalertminipro9090223333"
      resource_group_name = azurerm_resource_group.rg.name
      scopes              = [azurerm_linux_virtual_machine.vm.id]
      description         = "Alert when disk free space is less than 20%"
    
      criteria {
        metric_namespace = "Microsoft.Compute/virtualMachines"
        metric_name      = "Available Memory Bytes"
        aggregation      = "Average"
        operator         = "LessThan"
        threshold        = 50
      }
    
      action {
        action_group_id = azurerm_monitor_action_group.ag.id
      }
    }
    

    ⚠️ Important Learning (Real-World Insight)

    During testing I discovered:

    Azure VM metrics do NOT expose actual disk usage by default.

    This alert monitors memory (RAM), not filesystem disk space.

    Real disk monitoring requires:

    • Azure Monitor Agent
    • Log Analytics
    • Log-based alerts

    This was one of the biggest learning moments in this project 🧠


    Final Result

    We built a complete monitoring pipeline:

    EventWhat Happens
    CPU spikeAzure detects
    Alert rule firesAction group triggered
    Email sentAdmin notified

    What You Learned

    ✔ Terraform provisioning
    ✔ Remote configuration
    ✔ Azure networking
    ✔ Monitoring architecture
    ✔ Real difference between metric vs log alerts


    Final Thoughts

    This project transforms Terraform from:

    “tool that creates resources”

    into

    “tool that builds reliable production systems”

    Because infrastructure without monitoring is just waiting to fail.


    Happy learning 🚀

  • 6 – Additional Useful Features in SharePoint

    Table of Contents

    1. Searching, Collaboration, Navigation & RSS Feeds in SharePoint
  • Searching, Collaboration, Navigation & RSS Feeds in SharePoint

    In this section, you’ll explore some everyday SharePoint features that help you find information faster, collaborate with your team, navigate easily, and stay updated automatically.
    These tools may look simple, but together they make SharePoint feel less like a storage system and more like a smart workspace.

    💡 Why these features matter

    Video Explanation


    🔍 Searching in SharePoint

    SharePoint includes a powerful global search system available at the top of every site. It doesn’t just search file names — it searches inside files, lists, pages, images, and even metadata tags.

    This means you can locate almost anything across your workspace in seconds.

    1. Go to the search bar at the top of SharePoint.
    2. Type your keyword or phrase.
    3. Press Enter or click the 🔍 icon.

    Refine your results

    After searching, you can narrow results using:

    Tabs

    Filters

    ➡️ Clicking a result opens the exact item location, including breadcrumbs showing where it exists in SharePoint.


    💬 Collaboration & Social Features

    Modern SharePoint pages include interactive elements similar to social media platforms. Instead of emailing updates, conversations can happen directly on the content itself.

    This keeps communication contextual and organized.

    Collaboration tools available

    How to interact with a page

    1. Scroll to the bottom of a modern page.
    2. Click Like or type a comment.
    3. Use @Name to notify someone.
    4. Click Post to share.

    📢 Mentioned users receive a notification, helping teams respond quickly without separate messages.

    Page insights you can view


    🧭 Navigating the SharePoint Home Page

    The SharePoint Home page is a global dashboard — different from a site homepage.
    It acts as your personal starting point across all sites and content.

    You can return to it anytime using the Home icon (top left).

    What you’ll find here

    Frequently used sites

    Shortcut icons

    My Lists feature

    Shows every list you created across SharePoint — even from different sites.

    Each list displays:

    Create menu

    The Create (+) button lets you quickly create:

    ➡️ Think of this page as your SharePoint control center.


    📡 Creating an RSS Feed in SharePoint

    RSS feeds automatically notify you when changes occur in a list or library.
    Instead of checking manually, updates come to your RSS reader.

    This is especially useful for tracking uploads, edits, or team activity.

    Why use RSS feeds

    1. Open your SharePoint list or library.
    2. Switch to Classic View.
    3. Click the Library/List tab in the ribbon.
    4. Select RSS Feed.
    5. Copy the generated link.

    What happens after subscribing

    Whenever content changes:

    ➡️ Your RSS reader collects these updates automatically, keeping you informed without opening SharePoint repeatedly.


    Quick Recap

    Together, these features improve productivity by reducing navigation time and keeping everyone informed.

  • 5 – SharePoint Permissions : Step-by-step Video Guide

    Table of Contents

    1. 👥 Managing User Permissions in SharePoint (Visitors, Owners & Removal)
    2. Managing Default and Custom Permissions in SharePoint
  • 👥 Managing User Permissions in SharePoint (Visitors, Owners & Removal)

    Permissions are one of the most important parts of SharePoint. They control who can view, edit, or fully manage your site.
    Instead of giving everyone the same access, SharePoint organizes users into groups — making security easier and safer to manage.

    In this section, you’ll learn how to:

    🔐 Best Practice: Always grant the least privilege first. You can increase access later, but preventing accidental edits is much harder after they happen.

    Video Explanation


    🔹 Invite a User as a Visitor (Read-Only Access)

    Visitors are users who can view content but cannot edit anything.
    This is ideal for stakeholders, auditors, or team members who only need to read information.

    When added to the Visitors group, the user can open pages, lists, and documents — but editing options are hidden.

    What Visitors Can Do

    What Visitors Cannot Do

    Steps to Add a Visitor

    1. Click the ⚙ Settings icon (top right)
    2. Select Site permissions
    3. Scroll down and click Advanced permission settings
    4. Locate the Visitors group
    5. Click Grant Permissions
    6. Enter the user’s name or email
    7. Choose the Visitors group
    8. (Optional) Add a message
    9. Click Share / OK

    The user receives an email invitation and is automatically added after opening the link.

    💡 Tip: If a user should only see information and not modify it — always use the Visitors group.


    🔹 Promote a User to Site Owner (Full Control)

    Owners have the highest level of access in SharePoint.
    They can manage permissions, edit content, and configure the site.

    Only assign this role to trusted individuals responsible for maintaining the site.

    Owners Can

    Steps to Make a User an Owner

    1. Go to ⚙ Settings → Site permissions
    2. Open Advanced permission settings
    3. Select the Owners group
    4. Click New → Add users to this group
    5. Enter the user’s name
    6. Add a message (optional)
    7. Click Share / OK

    After accepting the email invitation, the user becomes a site owner immediately.

    ⚠️ Important: Owners can grant permissions to others — only assign this role when necessary.


    🔹 Remove a User from a Permission Group

    Sometimes access needs to be revoked — for example when a project ends or a team member changes roles.
    Removing a user from a group immediately updates their permissions.

    If they belong to multiple groups, they will still keep access from the remaining groups.

    Steps to Remove a User

    1. Go to ⚙ Settings → Site permissions
    2. Click Advanced permission settings
    3. Open the group (e.g., Owners)
    4. Select the user
    5. Click Actions → Remove users from group
    6. Confirm the removal

    The permission change takes effect instantly after refresh.

    🧠 Reminder: Removing from Owners does not remove access completely if the user still belongs to Members or Visitors.


    ✅ Quick Permission Overview

    GroupAccess LevelTypical Use
    VisitorsRead-onlyStakeholders, viewers
    MembersEdit contentTeam contributors
    OwnersFull controlSite administrators

    Proper permission management keeps your SharePoint environment secure, organized, and collaborative — while preventing accidental changes or data loss.

    Managing Default and Custom Permissions in SharePoint

    In this section, you’ll learn how SharePoint permissions actually work — not just how to click buttons, but why they’re structured this way.
    SharePoint follows a security model based on permission levels → assigned to groups → groups contain users.

    Understanding this flow is important because:

    Once you understand the default permissions, creating your own secure setup becomes much easier.

    Video Explanation


    1) Understanding Default Permission Levels

    Before creating custom permissions, it’s important to understand how SharePoint’s built-in permissions are structured.

    SharePoint comes with predefined groups and permission levels:

    Default Groups

    Each group is assigned a permission level, and that permission level is actually a collection of many smaller capabilities (view, edit, delete, manage site, etc.).

    How to View Default Permission Levels

    1. Click the Settings (⚙️) icon (top-right)
    2. Select Site permissions
    3. Click Advanced permission settings
    4. In the top menu, click Permission Levels

    You will see levels such as:

    Example: What “Read” Permission Allows

    Allowed

    Not Allowed

    👉 This is why Visitors can see content but cannot modify anything.

    Key Idea:
    The Read permission is intentionally restrictive — it protects your data while still allowing access.


    2) Creating a Custom Permission Level

    Sometimes default permissions are too broad.

    Example:

    So you create a custom permission tailored exactly to your needs.

    In our case:
    We want users to read and edit items but not fully control the site.

    Steps to Create Custom Permission

    1. Go to Permission Levels page (same place as above)
    2. Open the Read permission level
    3. Click Copy Permission Level

    Now configure it:

    Name: Read and Edit
    Description: Can read and edit items

    Modify Permissions

    Keep everything from Read AND additionally enable:

    Then click Create

    You now have a new permission level available alongside default ones.

    💡 Best Practice
    Create permissions based on real job responsibilities, not convenience.


    3) Create a Group and Assign the Custom Permission

    Permissions should be assigned to groups, not directly to users.
    This keeps your site manageable as your team grows.

    Why Use Groups?

    Create a New Group

    1. Go to Advanced permission settings
    2. Click Create Group

    Fill details:

    Group Name: Read and Edit Group
    Description: Members can read and edit

    Under Give group permissions to this site
    ✔ Select Read and Edit

    Click Create


    Add a User to the Group

    Now add people who should have this access.

    1. Open the newly created group
    2. Click New
    3. Enter the user name
    4. Add a message (optional)
    5. Click Share

    The user is now part of the group and automatically inherits permissions.


    What the User Can Do Now

    Because the user belongs to the custom group:

    They CAN

    They CANNOT

    This proves the custom permission works exactly as designed.


    Key Takeaways

    Using this approach keeps your SharePoint environment secure, organized, and easy to maintain as your organization grows.

  • 4 – Lists in SharePoint: A Video Guide

    Table of Contents

    1. 📋 Creating Lists in SharePoint
    2. ✏️ Editing Lists in SharePoint
    3. 🧩 Working with SharePoint List Features
    4. ⚙️ Working with Advanced Column Types in SharePoint Lists
    5. 🧮 Working with Calculated Columns in SharePoint
    6. 🔗 Creating and Using Lookup Columns in SharePoint Lists
    7. 💬 Adding Comments and Tracking Version History in SharePoint Lists
    8. 🧩 Working with Columns and Conditional Fields in SharePoint Lists
    9. ✅ Ensuring Proper Form Validation in SharePoint Lists
    10. 📅 Calendar View in a SharePoint List
    11. 🔔 Working with Alerts in Microsoft SharePoint
    12. 📤 Working with SharePoint Lists: Exporting and Deleting Data
  • 📋 Creating Lists in SharePoint

    SharePoint Lists are like smart, collaborative tables where teams can store, track, and manage information. Think of them as an upgraded version of Excel—built directly into SharePoint with powerful features like filtering, automation, and integration with Microsoft 365 tools.

    In this section, you’ll learn the different ways to create a list:

    Video Explanation


    🚀 Why Use SharePoint Lists?

    Before jumping into the steps, here’s why lists are so useful:


    🧱 Method 1 – Create a List from Excel

    If you already have data in Excel, you don’t need to retype anything.

    Step-by-Step

    1. Prepare Excel Data
    2. Import to SharePoint
    3. Configure Columns
    4. Create the List

    ✅ Your Excel data is now a fully functional SharePoint list!


    🧱 Method 2 – Create a List from Scratch

    Perfect when starting fresh.

    Steps

    1. Go to New → List → Blank List
    2. Give your list a name
    3. By default, you’ll get a Title column
    4. Add custom columns:
    1. Add items using New Item

    💡 Tip: You can rename the Title column to something meaningful like Employee ID.


    🧱 Method 3 – Create from an Existing List

    Reuse structure without rebuilding everything.

    1. Click New → List → From Existing List
    2. Choose a list to copy
    3. Give the new list a name
    4. Click Create

    👉 The new list will contain the same columns and settings.


    🧱 Method 4 – Use SharePoint Templates

    SharePoint includes ready-made list templates like:

    Just:

    1. Select New → List
    2. Scroll to Templates
    3. Pick one
    4. Name it → Create

    Instant professional structure! 🎉


    🎯 What You’ve Learned

    You can now create SharePoint lists:

    These lists can become the backbone of tracking customers, employees, assets, projects, and more.

    ✏️ Editing Lists in SharePoint

    SharePoint lists aren’t just for storing data—they’re meant to be edited, updated, and customized as your team works. SharePoint gives you multiple ways to modify list items: quick single-item edits, bulk updates using grid view, and even advanced customization through content types and form layouts.

    Let’s walk through the most practical ways to edit and manage your SharePoint lists.

    Video Explanation


    📝 Edit a Single List Item

    This is the most common method when you need to update one record or attach supporting files.

    How to edit an item:

    1. Go to your list from Site Contents
    2. Click the item you want to update
    3. Select Edit from the top menu (or from the three dots ⋯ menu)
    4. Update the fields in the form
    5. (Optional) Upload files in the Attachments section
    6. Click Save

    💡 Best for: Quick corrections, adding documents, or updating one record at a time.


    🔓 Enable “Allow Management of Content Types”

    Sometimes you may find that certain items can’t be edited. This usually happens because content type management is turned off.

    Enable it like this:

    After this:

    💡 Why this matters:
    It unlocks deeper control over list structure and ensures full editing flexibility.


    📊 Edit in Grid View (Excel-Style Editing)

    Need to update many rows fast? Grid view turns your list into a spreadsheet.

    Steps:

    1. Open the list
    2. Click Edit in grid view
    3. Update cells directly like Excel
    4. Click Exit grid view to save

    Best for: Bulk updates, data cleanup, and fast entry.


    🧩 Powerful Features in the Edit Form

    The SharePoint edit form includes more than just fields:

    These tools help you turn a simple list into a collaborative workspace.


    🎯 Key Takeaways

    With these options, SharePoint lists become flexible tools that adapt to how your team works—not the other way around. 🚀

    🧩 Working with SharePoint List Features

    SharePoint lists are more than simple tables—they’re interactive tools designed to help you explore, organize, and collaborate on data. In this section, we’ll look at some of the most useful built-in list features: sharing individual items, sorting and grouping, using the filter pane, and calculating column totals.

    These features make large datasets easier to understand and help teams work smarter together. 🚀

    Video Explanation


    🔗 1. Item Page in a SharePoint List

    Every list item has its own dedicated page where you can view details, track activity, and collaborate through comments.

    What you can do:

    How to share an item link:

    1. Open your list and select an item
    2. Click the three dots ⋯ next to it
    3. Choose Copy Link
    4. Share the URL with teammates

    💡 Perfect for: Sending someone directly to one record instead of the whole list.


    📊 2. Sort and Group Your Data

    Large lists can feel overwhelming—sorting and grouping help bring order.

    Benefits

    Try this:

    👉 To return to normal view, open the column menu again and uncheck Group by.


    🎯 3. Use the Filter Pane

    The filter pane lets you narrow results across multiple columns at once—great for big datasets.

    Steps

    1. Click the filter icon (top right)
    2. Select values from one or more columns
    3. Click Apply
    4. Use Clear All to reset

    Example:
    Filter Office = Toronto AND Brand = Mercedes to see only matching records.

    💡 Ideal for: Finding exactly what you need in seconds.


    ➕ 4. Column Totals

    Need quick calculations? SharePoint can show them directly in the list view.

    Available options

    How to enable totals:


    ✅ Key Takeaways

    With these features, SharePoint lists become a powerful dashboard for everyday teamwork—no technical skills required! 💪

    ⚙️ Working with Advanced Column Types in SharePoint Lists

    SharePoint lists become truly powerful when you move beyond simple text columns. By using advanced column types, you can tag items, assign ownership, and manage dates with precision—making your data easier to organize, search, and analyze.

    Let’s explore three essential column types:

    Video Explanation


    🏷 1. Multi-Select Choice Column – Smart Tagging

    Tags help categorize records so you can filter and group them later. A Choice column with multi-select lets users assign multiple labels to the same item.

    How to create it:

    1. Open your list → Add Column → Choice
    2. Name the column (e.g., Tags)
    3. Enter options such as:
    4. Enable Allow multiple selections
    5. (Optional) Turn on Allow values to be added manually
    6. Click Save

    What users see:
    When editing an item, they can pick multiple tags from a dropdown—perfect for flexible categorization.

    💡 Great for: Customer segmentation, project labels, priority flags.


    👤 2. Person or Group Column – Assign Ownership

    Need to assign a record to someone in your organization? The Person/Group column connects directly to your company directory.

    Steps to add:

    1. Click Add Column → Person or Group
    2. Name it (e.g., Associate)
    3. Enable Show profile photos (optional)
    4. Click Save

    How it works:

    💡 Perfect for: Assigning cases, owners, reviewers, or contacts.


    📅 3. Date Column – Convert Text to Real Dates

    If dates are stored as plain text, you lose sorting, filtering, and validation. Converting to a Date and Time column unlocks powerful features.

    Convert an existing column:

    1. Click the column header
    2. Select Column Settings → Edit
    3. Change type to Date and Time
    4. Optional:
    5. Click Save

    Result:
    Your dates can now be sorted chronologically, filtered by range, and used in automation.

    💡 Essential for: Birthdays, deadlines, renewals, and schedules.


    ✅ Why These Columns Make a Difference

    Column TypeBusiness Benefit
    Multi-Select ChoiceFlexible tagging & filtering
    Person/GroupClear ownership & collaboration
    DateAccurate time-based operations

    🎯 Final Thoughts

    Using the right column types transforms a basic SharePoint list into a smart information hub. You’ll get:

    Start upgrading your lists today and watch your data come to life! 🚀

    🧮 Working with Calculated Columns in SharePoint

    Ever wished SharePoint could do the math for you? That’s exactly what calculated columns are for! Instead of manually entering values like age, totals, or status messages, SharePoint can generate them automatically using formulas.

    For example, if your list has a Date of Birth column, you can create an Age column that updates itself—no manual updates needed. Let’s dive in!

    Video Explanation


    ✅ What Are Calculated Columns?

    A calculated column generates its value using data from other columns in the same list. It’s perfect for:


    🛠 How to Create a Calculated Column

    Step 1 – Add a New Column

    1. Open your SharePoint list
    2. Click Add Column
    3. Choose See all column types → click Next

    Step 2 – Select Calculated Type

    Step 3 – Enter the Formula

    To calculate age from Date of Birth:

    =DATEDIF([Date of Birth], TODAY(), "Y")
    

    Step 4 – Set Return Type

    Step 5 – Save 🎉

    Click OK—your Age column will now calculate automatically!


    💡 Tips for Writing Formulas


    📌 Useful Calculated Column Examples

    1. Create Full Name

    =[First Name] & " " & [Last Name]
    

    ➡ Combines two text fields with a space.

    2. Status Based on Percentage

    =IF([Completion] >= 100, "Completed", "In Progress")
    

    3. Add Price + Tax

    =[Price] + [Tax]
    

    4. Overdue Check

    =IF([Due Date] < TODAY(), "Overdue", "On Track")
    

    5. Days Remaining

    =[Due Date] - TODAY()
    

    6. Value Category

    =IF([Amount] >= 1000, "High Value", "Standard")
    

    7. Discounted Price

    =[Price] - ([Price] * [Discount]/100)
    

    8. Show Month Name

    =TEXT([Order Date], "mmmm")
    

    9. Time-Based Greeting

    =IF(HOUR(NOW())<12,"Good Morning","Good Afternoon")
    

    🚀 Why Calculated Columns Are Awesome


    🎯 Final Thoughts

    Calculated columns turn a simple SharePoint list into a mini application. Whether you’re calculating age, totals, statuses, or messages—SharePoint does the heavy lifting while you focus on insights.

    Start experimenting with formulas and make your lists work smarter, not harder! 💪

    🔗 Creating and Using Lookup Columns in SharePoint Lists

    Lookup columns are one of the most powerful features in SharePoint lists. They allow you to connect two lists together, so data can be reused instead of duplicated.

    For example, instead of typing the same repair shop details for every customer, you can maintain a separate Repair Shops list and simply link customers to it. Any updates to the shop details will automatically reflect in the Customers list. Smart, right? 😎

    Video Explanation


    ✅ Why Use Lookup Columns?


    1️⃣ Create a Source List (Repair Shops)

    Before creating a lookup column, we need a list that will act as the data source.

    🛠 Steps

    1. Go to your SharePoint site → New → List
    2. Choose Blank List and name it Repair Shops
    3. Add these columns:
    4. Rename the Title column → Shop ID (acts as unique identifier)

    ✏ Add Sample Data

    Shop IDShop NameEmailCity
    101QuickFix Repairsinfo@quickfix.comToronto

    🎉 This list will now be used as the lookup source.


    2️⃣ Create Lookup Column in Customers List

    Now we’ll connect the Customers list to Repair Shops.

    🛠 Steps

    1. Open the Customers list
    2. Click Add Column → See all column types → Next
    3. Configure:
    4. Under Add additional columns, select:
      ✔ Shop Name
      ✔ Email
    5. Click OK

    🎯 Result

    Your Customers list will now show:


    3️⃣ Test the Lookup Relationship

    🧪 Steps

    1. Edit a customer record
    2. In Repair Shop, choose a shop from dropdown
    3. Click Save

    ✅ The related Shop Name & Email appear automatically!


    🔄 What Happens When Source Data Changes?

    👉 If you update the email in Repair Shops,
    👉 The change instantly reflects in Customers list!

    Also:


    🚀 Key Benefits Recap


    💡 Pro Tip

    Use lookup columns for:


    Lookup columns transform SharePoint from simple lists into a mini relational database—without any coding. Start connecting your lists and make your data smarter today! 🚀

    💬 Adding Comments and Tracking Version History in SharePoint Lists

    SharePoint lists aren’t just for storing data—they’re built for team collaboration and accountability. Two standout features make this possible:

    Let’s see how these tools help keep communication clear and your data safe.

    Video Explanation


    🗨 Comments in SharePoint Lists — Collaborate in Context

    Comments let your team talk about a list item right where the data lives. No more hunting through emails or chats to find updates!

    🌟 Why Comments Are So Useful


    🧭 How to Add a Comment

    1. Open your SharePoint list
    2. Click the item you want to discuss
    3. Select Edit to open the item form
    4. On the right side, find the Comments section
    5. Type your message
    6. Use @Name to mention a colleague
    7. Click Send

    💡 Tip: When you @mention someone, they get a notification—great for quick follow-ups!


    🕓 Version History — Never Lose Track of Changes

    Version History records every update made to a list item:

    If something goes wrong, you can easily roll back to an earlier version.


    🎯 Why Use Version History?


    🧭 How to View Version History

    1. Go to your list
    2. Click the three dots (…) next to an item
    3. Select Version History

    You’ll see:


    🔁 What You Can Do from Here

    For any version, you can:

    ✅ Restoring doesn’t erase newer versions—it simply creates a new “latest” version based on the old one.


    ⚙ Pro Tip: Enable Versioning

    Make sure version history is turned on:

    List Settings → Versioning Settings → Enable versioning

    This ensures SharePoint keeps a full timeline of edits.


    🚀 Key Takeaways

    Together, these features turn SharePoint lists into a true collaboration workspace, not just a spreadsheet replacement 👍

    🧩 Working with Columns and Conditional Fields in SharePoint Lists

    SharePoint lists become truly powerful when you start customizing columns and adding smart conditional logic. Instead of overwhelming users with unnecessary fields, you can show only what’s relevant—keeping forms clean, accurate, and easy to use 👍.

    In this section, we’ll cover:

    Let’s build this step by step!

    Video Explanation


    ➕ Adding Additional Columns to a List

    As your business grows, your lists often need to capture more information. Adding new columns lets you expand without breaking existing data.

    🧪 Example Scenario

    You have a Repair Shops list with:

    Now you want to track:


    🧭 Steps to Add New Columns

    1. Open your SharePoint list
    2. Click + Add column
    3. Choose Choice
    4. Name it Shop Type
    5. Add choices:
    6. Enable: Require that this column contains information
    7. Click Save

    Now add the second column:

    1. Click + Add column
    2. Select Single line of text
    3. Name it Affiliation
    4. Click Save

    ✅ Your list now includes two new structured fields!


    ✏ Adding Values to Existing Items

    After creating columns, update current rows so they follow the new structure.

    🧭 How to Update an Item

    1. Select a row → Click Edit
    2. For an independent shop:
    3. For an affiliated shop:
    4. Click Save

    ⚠ Problem:
    Even when Independent is selected, users can still type an affiliation.
    Let’s fix that with conditional logic!


    🎯 Applying Conditional Visibility to Columns

    We can make the form smarter:

    👉 Show Affiliation field ONLY when
    Shop Type = Affiliated


    🧭 Steps to Add a Condition

    1. Click Add new item
    2. In the form, open:
      Edit Form → Edit Columns
    3. Find Affiliation column
    4. Click ⋯ → Edit conditional formula
    5. Enter a formula like:
    =if([$ShopType] == "Affiliated", true, false)
    
    1. Save all changes

    🧪 Test the Behavior

    Shop Type SelectedAffiliation Field
    Independent❌ Hidden
    Affiliated✅ Visible

    🎉 Now your form stays clean and error-free!


    🚀 Why This Matters


    🧠 Quick Recap

    ✅ Ensuring Proper Form Validation in SharePoint Lists

    When users enter data into a SharePoint list, there’s always a risk of missing or incorrect information. Without validation, important fields can be skipped—leading to incomplete records and messy data 😬.

    Thankfully, SharePoint provides built-in validation tools that let you:

    Let’s walk through a real-world example:
    👉 If a repair shop is marked as “Affiliated,” the Affiliation name must be required.

    Video Explanation


    ⚠ What Happens Without Validation?

    Imagine your list has:

    By default, SharePoint allows this:

    ❌ User selects Affiliated
    ❌ Leaves Affiliation blank
    ✔ The form still saves!

    This creates confusing, incomplete data—exactly what we want to avoid.


    🛠 Adding Row Validation in SharePoint

    Row validation lets you define rules that must be satisfied before an item can be saved.


    🧭 Steps to Add Validation

    1. Open your SharePoint list
    2. Click the ⚙ Settings icon
    3. Select List settings
    4. Click Validation settings

    You’ll see two fields:


    ✏ Example Validation Formula

    Rule:

    If Shop Type = “Affiliated”, then Affiliation must not be blank

    =IF([Shop Type]="Affiliated", NOT(ISBLANK([Affiliation])), TRUE)
    

    💬 User-Friendly Error Message

    In the User Message box, add something like:

    ❗ “Affiliation is required when Shop Type is set to Affiliated.”

    This helps users understand exactly what to fix 👍.


    🧪 Test the Validation

    Try these scenarios:

    Shop TypeAffiliationResult
    AffiliatedBlank❌ Error – cannot save
    Affiliated“Mega Repairs”✅ Saves
    IndependentBlank✅ Saves

    🎯 Perfect! The rule only applies when needed.


    🎯 Key Benefits of Validation


    🧠 Quick Recap

    📅 Calendar View in a SharePoint List

    SharePoint lists don’t have to stay as rows and columns! With Calendar View, you can transform date-based data into a visual calendar layout—making it easier to track events, deadlines, and milestones at a glance.

    Instead of scrolling through long tables, you’ll see items displayed on days, weeks, or months—just like a real calendar 🗓️.

    💡 Important: Calendar View only works if your list has at least one Date-type column. Without a date field, SharePoint won’t know what to plot on the calendar.

    Video Explanation


    🔑 Why Use Calendar View?

    Calendar View is perfect when your list contains time-based information. It helps you:

    Great for scenarios like:


    🛠 How to Create a Calendar View

    Follow these simple steps to turn your list into a calendar:

    1. Open your SharePoint list
      Go to the list that contains a date column (e.g., Sign-up Date, Due Date, Event Date).
    2. Add a New View
      At the top right—just above the column headings—click ➕ Add View.
    3. Name the View
      In the pop-up window, give it a name like:
      👉 Calendar View
    4. Select a Date Column
      Choose which date field should drive the calendar.
      Examples:
    5. Choose a Layout
      Set the default display:
    6. Click Create
      🎉 Your list now appears in a calendar format!

    🖼 Practical Example

    Imagine you have a Customer Sign-up Date column:

    Much more intuitive than reading dates in a table!


    🎯 Best Use Cases

    ScenarioWhy Calendar View Helps
    Project deadlinesSee upcoming tasks visually
    Event planningAvoid date clashes
    Support ticketsTrack SLA dates
    Employee leaveView overlaps easily

    ✅ Key Takeaways

    🔔 Working with Alerts in Microsoft SharePoint

    SharePoint alerts help you stay updated without constantly checking your lists. Once configured, SharePoint automatically notifies you whenever important changes occur—whether to a single item or the entire list. This is perfect for tracking updates like status changes, new entries, or edits made by team members.

    Video Explanation


    📌 Create an Alert for a Specific List Item

    Sometimes you only need to monitor one critical record instead of the whole list. SharePoint lets you set alerts at the item level, so you get notified only when that particular item changes.

    How to create an alert:

    1. Open your SharePoint list and locate the item.
    2. Click the three dots (…) next to the item.
    3. Select Alert me from the menu.

    You can then configure:

    Click OK to activate the alert.


    ✉ What Happens After an Update

    Whenever that item is modified, SharePoint sends an email containing:

    This keeps everyone informed without manual follow-ups.


    🧰 Manage or Remove Alerts

    As your project grows, you may want to review or clean up alerts.

    To manage alerts:

    1. Open the list
    2. Click Manage my alerts from the top menu
    3. From here you can:

    💡 Tip: List-level alerts are great when you need to track new items or bulk changes instead of one record.


    🎯 Why Use Alerts?


    ✅ Quick Recap

    📤 Working with SharePoint Lists: Exporting and Deleting Data

    Managing SharePoint lists isn’t just about adding data—you’ll often need to export information for reports or clean up outdated records. SharePoint makes both tasks simple with built-in tools, no extra software required.

    In this section, we’ll cover:

    Video Explanation


    📥 Export a SharePoint List

    Need to analyze your data in Excel or build dashboards in Power BI? Exporting lets you take your SharePoint list outside the platform in seconds.

    🚀 Why Export?

    ✅ Export Formats Available

    🧭 Steps to Export

    1. Open your SharePoint list
    2. Click the Export dropdown at the top
    3. Choose your preferred format
    4. The file downloads instantly to your device

    💡 Tip: Export to Excel keeps column structure intact, making it easy to continue working with the data offline.


    🗑 Delete a SharePoint List Item (With Restore Option)

    Cleaning up old or incorrect records keeps your list accurate and relevant. The good news? Deleted items aren’t gone forever—they go to the Recycle Bin first.

    🧹 How to Delete an Item

    1. Select the item from the list
    2. Click Delete from the top menu
    3. Confirm the action

    The item disappears from the list—but stays recoverable.

    ♻ How to Restore a Deleted Item

    1. Open the Recycle Bin (left navigation)
    2. Find your deleted item
    3. Click Restore

    The item returns exactly to its original location 🎉

    🛡 Safety Net: SharePoint’s recycle bin protects you from accidental deletions.


    ⚠ Delete an Entire SharePoint List

    If a list is no longer needed, you can remove it completely.

    Steps to Delete a List

    1. Open the list
    2. Click the Settings gear icon
    3. Select List Settings
    4. Choose Delete this list
    5. Confirm the action

    ❗ Important: Deleting a list removes all items inside it—double-check before proceeding.


    ✅ Quick Summary

    TaskBest For
    Export to ExcelReports & calculations
    Export to CSVSystem integrations
    Export to Power BIDashboards
    Delete ItemData cleanup
    Restore ItemUndo mistakes
    Delete ListRemoving unused data
  • 3 – Understanding SharePoint Pages: A Complete Guide with Video Explanation

    Table of Contents

    1. Introduction to SharePoint Pages
    2. 📄 How to Create a Wiki Page in SharePoint — Step-by-Step Guide
    3. 📁 Embedding a Document Library into a SharePoint Page
    4. 🔧 Customizing an Embedded Document Library (App Part) in SharePoint Pages
    5. 📄 How to Add Images and Links in a SharePoint Wiki Page
    6. 🔄 Viewing Page History and Embedding Content in SharePoint Pages
    7. 📄 How to Create a Modern Site Page in SharePoint
    8. 🖌️ How to Enhance a SharePoint Site Page with Layout Edits & an Embedded Picture Library
    9. 🧑‍🤝‍🧑 How to Add People to a SharePoint Site Page
    10. 🕒 How to Add a Countdown Timer to a SharePoint Site Page
    11. 🧭 How to Add Navigation Elements to a SharePoint Page
    12. 🏠 How to Create and Customize a SharePoint Home Page
    13. 🧰 Useful Menu Items on SharePoint Site Pages
  • Introduction to SharePoint Pages

    In SharePoint, pages are the foundation of how content is presented and shared across a site. They allow you to display documents, announcements, dashboards, and project information in a structured and visually organized way. Whether you’re building an internal knowledge base, a team portal, or a company intranet, pages determine how users experience and interact with your content.

    SharePoint offers several types of pages, each designed for different scenarios and levels of customization.


    Types of SharePoint Pages

    Site Pages (Modern Pages)

    These are the default and recommended page type in today’s SharePoint. Site pages are built using web parts, making it easy to add text, images, document libraries, news, and more without technical skills.

    Best features:

    Site pages are ideal for team homepages, announcements, dashboards, and general communication.


    Wiki Pages (Classic)

    Wiki pages provide more free-form editing, similar to a word processor. Users can add formatted text, tables, links, and images directly on the page without structured web parts.

    Good for:

    Although still supported, wiki pages belong to the classic SharePoint experience and are gradually being replaced by modern site pages.


    Web Part Pages (Legacy)

    Web part pages come from older versions of SharePoint and allow detailed layout control using zones and classic web parts. However, they are now considered outdated.

    Limitations:

    These pages should only be used when required for legacy systems or older integrations.


    When to Use Each Page Type


    Understanding the different SharePoint page types helps you design sites that are easy to navigate, visually appealing, and aligned with modern collaboration needs. By selecting the right page type for the right purpose, you create a better experience for everyone who uses your SharePoint site.

    📄 How to Create a Wiki Page in SharePoint — Step-by-Step Guide

    Wiki pages may be part of SharePoint’s classic experience, but they’re still useful when you need free-form editing similar to a Word document. They’re great for quick documentation, internal notes, or simple knowledge-base pages where structure matters less than flexibility.

    Let’s walk through how to create, edit, and publish a wiki page in a clear and easy way.

    Video Explanation


    🛠 Step-by-Step: Creating Your Wiki Page

    ➤ 1. Go to the Pages Library

    ➤ 2. Create a New Page

    💡 Tip: Site Pages are the modern default, but Wiki Pages are perfect when you want a simple, document-style layout.

    ➤ 3. Name Your Page

    A good name helps users find the page easily later.

    ➤ 4. Add Your Content

    You’ll now see an editor that feels a lot like Microsoft Word:

    This flexibility is what makes wiki pages great for informal documentation.

    ➤ 5. Save & Publish


    📂 How to Find Your Page Later

    To reopen or edit the page:

    1. Go back to Pages in the site menu.
    2. Click the page name (for example, Expense Page).
    3. Choose Edit if you need to make updates.

    Easy and always accessible 👍


    💬 When Should You Use a Wiki Page?

    ScenarioGood Fit?
    Quick internal documentation✅ Yes
    Knowledge base articles✅ Yes
    Modern dashboards❌ Better with Site Pages
    Mobile-friendly layouts❌ Use Site Pages

    📌 Remember: Wiki pages are classic technology. For modern, responsive designs, Site Pages are recommended—but wiki pages remain handy for simple, text-focused content.


    🎯 Summary

    📁 Embedding a Document Library into a SharePoint Page

    One of the smartest ways to make SharePoint easier for users is to bring the tools to the page instead of sending users around the site. By embedding a document library directly into a page, you can combine instructions, context, and file management in a single, friendly interface.

    This approach is perfect for scenarios like expense submissions, project file uploads, or team collaboration spaces.

    Video Explanation


    🎯 Why Embed a Document Library?

    Adding a library to a page gives you several advantages:

    Think of it like building a mini workspace inside a page instead of just a blank information screen.


    🛠 Step-by-Step: Add a Library to a Page

    1️⃣ Open the Page


    2️⃣ Switch to Edit Mode


    3️⃣ Choose a Layout

    This gives you:


    4️⃣ Add Helpful Instructions

    In the header and left column, add guidance such as:

    💬 “Upload your expense reports using the panel on the right.”
    💬 “Use this file naming format: Department_Date.pdf”

    Clear instructions = fewer mistakes 👍


    5️⃣ Insert the Document Library (App Part)

    Now for the magic part ✨

    1. Click inside the right column
    2. Open the Insert tab
    3. Select App Part
    4. Choose your library (e.g., Expenses)
    5. Click Add

    Your live document library now appears inside the page!


    6️⃣ Save & Publish


    🚀 What Users Can Do Now

    From this single page, users can:

    👉 No more jumping between Pages, Site Contents, and Libraries!


    💡 Best Use Cases

    ScenarioPerfect Fit?
    Expense submissions✅ Yes
    Project file collection✅ Yes
    HR document uploads✅ Yes
    Simple read-only info❌ Use normal page

    🧠 Final Thought

    Embedding a document library turns a simple SharePoint page into a functional workspace. It combines guidance + action in one place — exactly what end users need to stay productive without confusion.

    Give it a try on your next SharePoint page and watch how much smoother your team workflows become 🚀

    🔧 Customizing an Embedded Document Library (App Part) in SharePoint Pages

    Embedding a document library inside a SharePoint page is powerful—but the real magic happens when you customize how that library appears and behaves. You can group files, hide unnecessary columns, or even turn the library into a read-only viewer so users can’t upload or modify content.

    Let’s walk through how to fine-tune your embedded library for a cleaner and more user-friendly experience.

    Video Explanation


    🎯 What You Can Achieve

    With App Part customization, you can:


    ✅ Step 1: Create a Custom View in the Library

    The embedded library will display whatever view you choose, so start by creating one tailored for your page.

    ➤ Create the View

    1. Open your Expenses document library
    2. Click the view dropdown (e.g., All Documents)
    3. Select Create new view
    4. Name it something clear like:
      👉 Expense Page View

    ➤ Customize the View

    After creating it:

    1. Open the view dropdown again
    2. Click Edit current view

    Now configure:

    Click OK to save.

    👀 This is exactly how the library will look when embedded in the page.


    ✅ Step 2: Apply That View to the Page

    Now connect the page to this new view.

    ➤ Open the Page

    1. Go to Pages from site navigation
    2. Open your page (e.g., Expense Page)
    3. Click Edit ✏️

    ➤ Configure the App Part

    1. Click once on the embedded document library
    2. A Web Part tab appears at the top
    3. Select Web Part Properties

    In the right panel:

    Optional tweaks:

    Click Apply.


    ✅ Step 3: Make It Read-Only (Optional)

    Want users to only view files — not upload or edit?

    ➤ Turn Off the Toolbar

    In Web Part Properties:

    1. Find Toolbar Type
    2. Select 👉 No Toolbar

    ✨ Result:


    🧠 Final Result

    Your page now:


    🚀 Why This Matters

    This setup is perfect for:

    You get the best of both worlds:
    👉 Guided page experience + live library functionality


    🎉 Summary

    By customizing the embedded App Part, you transform a basic page into a purpose-built workspace that’s clear, controlled, and easy for users to navigate.

    Ready to level up your SharePoint pages? This technique is a game changer 💪

    Adding images and links to a SharePoint wiki page transforms plain text into a visual, easy-to-navigate workspace. A banner image can make your page look professional, while links guide users directly to the right documents or libraries.

    Let’s walk through how to do both—step by step 👇

    Video Explanation


    🖼️ Insert an Image into a Wiki Page

    1. Open the Page

    2. Add the Image

    3. Adjust the Image

    💡 Tip: Use a wide, lightweight image for a clean banner look.


    1. Insert the Link

    2. Open in a New Tab (Recommended)


    🧭 Update Site Navigation

    Add the Page to Navigation

    Optional Cleanup


    🎯 Result

    Your wiki page now includes:

    This structure helps users understand the page quickly and reach the right content with minimal effort 🚀

    🔄 Viewing Page History and Embedding Content in SharePoint Pages

    SharePoint pages evolve over time, and it’s important to track what changes have been made and by whom. SharePoint provides a built-in Page History feature for this purpose. In addition, you can enrich your pages by embedding external content such as YouTube videos, dashboards, or other web resources using embed code.

    Video Explanation


    📖 Viewing Page History

    Page History allows you to review previous versions of a page and compare edits.

    Steps to view history:

    1. Open the SharePoint page you want to review (for example, Expense Page).
    2. Click Edit at the top-right corner.
    3. From the Page tab, select Page History.

    A panel will appear listing all saved versions of the page.

    What you can do:

    This feature is extremely useful for auditing edits or restoring previous content if needed.


    🎥 Embedding a YouTube Video or Other Content

    You can make your SharePoint pages more engaging by embedding content from external sources.

    How to embed a video:

    1. Open the YouTube video (or another service that provides embed code).
    2. Click Share → Embed and copy the HTML code.
    3. Return to your SharePoint page in Edit mode.
    4. Place the cursor where you want the video to appear.
    5. Go to the Insert tab and choose Embed Code.
    6. Paste the copied code and click Insert.
    7. Click Save and Publish to make the changes live.

    The video will now appear directly on your page and can be played without leaving SharePoint.


    ✅ Benefits

    Using these features together helps you:

    With Page History and embedding, SharePoint pages become powerful communication tools rather than simple static documents.

    📄 How to Create a Modern Site Page in SharePoint

    Modern Site Pages are the heart of today’s SharePoint experience. They let you create clean, visually appealing pages using drag-and-drop web parts—no technical skills required. Compared to older Wiki pages, Site Pages feel more like building a modern website: responsive, flexible, and easy for everyone to use.

    In this section, you’ll learn how to create a Site Page from scratch and customize it to fit your team’s needs.

    Video Explanation


    🧭 Step-by-Step: Create Your First Site Page

    Follow these simple steps to get started:

    1. Open the Pages library
    2. Create a new page
    3. Add a page title
    4. Customize the banner
    5. Add content sections
    6. Publish the page

    🚀 After You Publish

    SharePoint gives you helpful options right away:


    ✨ Why Use Modern Site Pages?

    Modern Site Pages are perfect for:

    They combine professional design + easy editing + powerful integration with the rest of Microsoft 365.

    🖌️ How to Enhance a SharePoint Site Page with Layout Edits & an Embedded Picture Library

    Modern SharePoint Site Pages are designed to look clean, visual, and professional without any technical skills. With just a few clicks, you can transform a simple page into an engaging space that combines banners, structured layouts, and live image galleries.

    In this section, you’ll learn how to upgrade an existing Site Page by customizing the banner, adjusting the layout, and embedding a picture library so users can view images directly from the page.

    Video Explanation


    ✏️ Step 1 – Open the Page in Edit Mode

    💡 Tip: Use the full-screen ↗ icon to hide navigation and focus only on the page while editing.


    🖼️ Step 2 – Customize the Banner

    The banner sets the mood of your page — make it informative and attractive.

    You can also:

    🎨 A well-designed banner gives instant context to your page visitors.


    🧩 Step 3 – Add a Structured Section

    To organize content neatly:

    1. Scroll below the banner
    2. Click the ➕ Add section icon
    3. Choose a layout such as Two Columns

    For better balance:


    📸 Step 4 – Embed the Picture Library

    Now let’s bring images directly onto the page:

    1. Inside the column, click ➕ Add web part
    2. Select Document Library
    3. Choose your Cars picture library

    ✨ Instantly, thumbnails from the library appear on the page — no manual uploads required!

    This is ideal for:


    🚀 Step 5 – Publish the Page

    When everything looks good:


    ✅ What You Get

    After these updates, your page now includes:

    This approach turns SharePoint pages into interactive visual hubs instead of plain text screens, making content easier and more enjoyable to explore.

    🧑‍🤝‍🧑 How to Add People to a SharePoint Site Page

    Adding people profiles to a SharePoint page is a great way to make your site feel more human and connected. Whether you’re building a team directory, highlighting project owners, or showing key contacts, the People web part lets you display names, photos, roles, and contact details in a professional layout.

    In this section, you’ll learn how to insert and customize a People section so visitors can easily recognize and reach the right person.

    Video Explanation


    ✅ Step-by-Step: Add the People Web Part

    1️⃣ Open the Page in Edit Mode

    2️⃣ Choose Where to Place It

    3️⃣ Insert the People Web Part

    4️⃣ Add Team Members

    💡 SharePoint automatically pulls profile photos and contact info from Microsoft 365.


    🎨 Customize the Look

    Click on the People web part and open Properties ⚙️ to adjust:

    Layout options:

    Optional descriptions:


    🚀 Publish the Changes


    👀 What Visitors Will See

    Your page will now show:

    This is perfect for:


    🌟 Why Use the People Web Part?

    🕒 How to Add a Countdown Timer to a SharePoint Site Page

    A countdown timer is a simple but powerful way to grab attention on your SharePoint site. Whether you’re counting down to a product launch, company event, project deadline, or registration closing date, this web part creates urgency and keeps everyone focused on what matters next.

    The best part? SharePoint includes a built-in Countdown Timer web part—no coding or third-party tools needed 👍.

    In this section, you’ll learn how to add, customize, and publish a live countdown timer on any modern SharePoint page.

    Video Explanation


    🔧 Step-by-Step: Add the Countdown Timer

    1️⃣ Open the Page in Edit Mode


    2️⃣ Add a New Section


    3️⃣ Insert the Countdown Web Part


    ⚙️ Customize Your Timer

    Click on the timer and open Properties ⚙️ on the right to configure:

    🎯 Set the Basics

    ⏱ Choose What to Display

    Select which units to show:

    You can keep it simple (days + hours) or ultra-precise with seconds ticking away!


    🔗 Add a Call to Action (Optional)

    Want users to take action before time runs out?


    🖼 Make It Visually Engaging

    Give your timer more impact with a background:

    This helps the timer stand out instead of looking like plain text.


    🚀 Publish the Page


    🎉 What You Get

    Your SharePoint page will now feature:


    💡 Great Use Cases

    🧭 How to Add Navigation Elements to a SharePoint Page

    Adding navigation elements like Call to Action (CTA) blocks and buttons makes your SharePoint pages easier to use and more interactive. Instead of forcing users to hunt through menus, you can guide them directly to key areas such as the Home page, Expense page, or any important resource.

    These elements act like signposts on your site—helping visitors move smoothly from one section to another.

    Video Explanation


    🚀 Why Add Navigation Elements?

    Using CTAs and buttons on your pages helps to:


    🔧 Step-by-Step: Add Navigation Elements

    1️⃣ Open the Page in Edit Mode

    2️⃣ Add a New Section

    3️⃣ Insert a Call to Action (CTA)

    Then configure it in the properties panel:

    4️⃣ Add a Navigation Button

    5️⃣ Publish and Test


    💡 Tips for Better Navigation


    🎯 What You Achieve

    With these additions your page will:

    A few well-placed navigation elements can transform a basic SharePoint page into a user-friendly hub 👍.

    🏠 How to Create and Customize a SharePoint Home Page

    Your SharePoint Home Page is the front door to your site. It’s where users land first, so it should be informative, organized, and easy to navigate. With modern SharePoint, you can build a custom homepage using web parts like News, Calendar, Quick Links, and Activity — all without any coding.

    In this section, you’ll learn how to design a professional homepage from scratch and set it as the default landing page for your site.

    Video Explanation


    ✨ What Makes a Good SharePoint Home Page?

    A well-designed homepage should:

    Let’s build one step by step 👇


    🛠 Step-by-Step: Build Your Custom Home Page

    1️⃣ Create a New Site Page

    2️⃣ Customize the Banner


    🧩 Add Useful Web Parts

    3️⃣ Add News & Calendar Section

    In the left column:

    In the right column:

    👉 This gives users a quick snapshot of what’s happening.


    4️⃣ Add Quick Navigation Cards

    Add another section with One Column layout and insert:

    For each CTA you can configure:

    These act like visual shortcuts across your site.


    5️⃣ Add Site Activity Feed

    At the bottom of the page:

    This shows:

    Great for keeping the homepage “alive” 🔄


    🚀 Publish & Set as Home Page

    When you’re happy with the design:

    1. Click Publish
    2. Go back to the Pages library
    3. Find your new page
    4. Click the three dots (…) → select Make homepage

    ✅ Now this page becomes the default landing page when users click the Home icon.


    🎯 Final Result

    Your custom homepage now includes:

    This transforms SharePoint from just a file storage space into a real digital workplace hub.

    🧰 Useful Menu Items on SharePoint Site Pages

    SharePoint Site Pages include several built-in tools that help you understand page performance, promote content, and manage page details—all from the top menu. These features make it easy to turn a simple page into a well-managed, high-impact resource.

    Let’s explore the three most useful options 👇

    Video Explanation


    📊 1. Page Analytics — Understand Your Audience

    The Analytics option gives you valuable insights into how users interact with your page.

    When you click Analytics, you can see:

    💡 Great for:
    Checking whether important pages are actually being used and identifying the best time to post updates.


    📣 2. Promote — Share Your Page with the Team

    The Promote button helps you surface your page in different places without extra effort.

    From the promote panel you can:

    💡 Great for:
    Turning a normal page into a highlighted announcement or reusable template.


    🗂 3. Page Details — Manage Metadata

    The Page Details option opens a side panel with important information about the page.

    Here you can:

    💡 Great for:
    Keeping pages structured and searchable across your SharePoint site.


    🎯 Why These Tools Matter

    Using these menu features helps you:

    With just a few clicks, you can manage your SharePoint pages like a pro 👍.

  • 11 – Azure SQL Database Server Terraform Mini Project — Step-by-Step Guide

    In this hands-on tutorial, we will build a complete Azure SQL Server + SQL Database using Terraform, then securely connect to it from our local machine and run real SQL commands — without installing SSMS or Azure Data Studio.

    This mini project is perfect if you are learning:

    • Terraform Infrastructure as Code
    • Azure SQL PaaS services
    • Networking security with firewall rules
    • Database connectivity using Azure CLI and sqlcmd

    Let’s build everything step by step.

    Table of Contents

    1. What We Will Build
    2. Step 1 – Create Resource Group, SQL Server and Database
    3. Step 2 – Add Firewall Rule to Allow Local PC
    4. Step 3 – Test SQL Using CLI (No GUI Needed)
    5. Step 4 – Connect to Database Using sqlcmd
    6. Step 5 – Create Table and Insert Data
    7. What We Learned

    What We Will Build

    By the end of this demo, we will have:

    • An Azure Resource Group
    • Azure SQL Server
    • Azure SQL Database
    • Firewall rule to allow our PC to connect
    • Real database table with data
    • Full connectivity test using CLI

    Step 1 – Create Resource Group, SQL Server and Database

    First we define the core infrastructure using Terraform.

    Resource Group — rg.tf

    resource "azurerm_resource_group" "rg" {
      name     = "rgminipro98989"
      location = "Central US"
    }
    

    The resource group is a logical container that will hold our SQL server and database.


    SQL Server — sqlserver.tf

    resource "azurerm_mssql_server" "sql_server" {
      name                         = "sqlserverminipro876811"
      resource_group_name          = azurerm_resource_group.rg.name
      location                     = azurerm_resource_group.rg.location
      version                      = "12.0"
      administrator_login          = "sqladmin"
      administrator_login_password = "StrongPassword@123"
    }
    

    This creates:

    • Azure SQL logical server
    • Admin user and password
    • Hosted in Central US

    In real projects, never hardcode passwords — use Azure Key Vault or Terraform variables.


    SQL Database — sqldb.tf

    resource "azurerm_mssql_database" "sqldb" {
      name      = "sqldbminipro81829"
      server_id = azurerm_mssql_server.sql_server.id
    }
    

    This database is created inside the SQL server defined earlier.


    Deploy Infrastructure

    Run:

    terraform init
    terraform apply
    

    After apply completes:

    • Open Azure Portal
    • Navigate to your resource group
    • Verify SQL Server and Database exist

    Step 2 – Add Firewall Rule to Allow Local PC

    By default, Azure SQL blocks all external connections.
    We must allow our own IP address.

    Firewall Rule — firewallrule.tf

    resource "azurerm_mssql_firewall_rule" "firewall_rule" {
      name             = "sqlfirewallruleminipro909122"
      server_id        = azurerm_mssql_server.sql_server.id
      start_ip_address = ""
      end_ip_address   = ""
    }
    

    👉 Replace the empty IP values with your public IP.

    You can find your IP from:

    https://whatismyipaddress.com

    Example:

    start_ip_address = "203.0.113.10"
    end_ip_address   = "203.0.113.10"
    

    Apply again:

    terraform apply
    

    Step 3 – Test SQL Using CLI (No GUI Needed)

    We will connect using:

    • Azure CLI
    • sqlcmd tool

    List SQL Servers

    az sql server list -o table
    

    List Databases in Our Server

    az sql db list --server sqlserverminipro876811 --resource-group rgminipro98989 -o table
    

    Check Firewall Rules

    az sql server firewall-rule list --server sqlserverminipro876811 --resource-group rgminipro98989 -o table
    

    Step 4 – Connect to Database Using sqlcmd

    No SSMS required!

    Connect

    sqlcmd -S sqlserverminipro876811.database.windows.net -U sqladmin -P "StrongPassword@123" -d sqldbminipro81829
    

    IMPORTANT:
    Use full DNS name →
    sqlserverminipro876811.database.windows.net


    Verify Databases

    SELECT name FROM sys.databases;
    GO
    

    Every SQL command must end with:

    GO
    

    Step 5 – Create Table and Insert Data

    Create Table

    CREATE TABLE employees(
      id INT PRIMARY KEY,
      name VARCHAR(50),
      tech VARCHAR(30)
    );
    GO
    

    Insert Sample Data

    INSERT INTO employees VALUES
    (1, 'Alice', 'Terraform'),
    (2, 'Bob', 'Azure'),
    (3, 'Charlie', 'SQL');
    GO
    

    Query Data

    SELECT * FROM employees;
    GO
    

    🎉 You should see real output from Azure SQL Database!


    What We Learned

    In this mini project you successfully:

    • Provisioned Azure SQL using Terraform
    • Understood logical SQL server vs database
    • Configured network security via firewall
    • Connected securely from local PC
    • Executed real SQL queries using CLI

    This is exactly how cloud engineers deploy database environments in real projects — automated, repeatable, and infrastructure as code.