Friday, 23 January 2026

Exception calling "ChangeDatabaseInstance" with "1" argument(s)

Exception calling "ChangeDatabaseInstance" with "1" argument(s)

PS C:\Users\admin> $db.ChangeDatabaseInstance("DBNAME")
Exception calling "ChangeDatabaseInstance" with "1" argument(s): "An update
conflict has occurred, and you must re-try this action. The object SPServer
Name=SERVERNAME was updated by admin, in the powershell (2572)
process, on machine SERVERNAME.  View the tracing log for more information
about the conflict."
At line:1 char:1



Solution: Clear the Cache

Run the below script

Add-PSSnapin -Name Microsoft.SharePoint.PowerShell –erroraction SilentlyContinue

Stop-Service SPTimerV4
$folders = Get-ChildItem C:\ProgramData\Microsoft\SharePoint\Config
foreach ($folder in $folders)
    {
    $items = Get-ChildItem $folder.FullName -Recurse
    foreach ($item in $items)
        {
            if ($item.Name.ToLower() -eq "cache.ini")
                {
                    $cachefolder = $folder.FullName
                }
               
        }
    }
$cachefolderitems = Get-ChildItem $cachefolder -Recurse
    foreach ($cachefolderitem in $cachefolderitems)
        {
            if ($cachefolderitem -like "*.xml")
                {
                   $cachefolderitem.Delete()
                }
       
        }
       
$a = Get-Content  $cachefolder\cache.ini
$a  = 1
Set-Content $a -Path $cachefolder\cache.ini


Indexing in SharePoint: How It Works, Best Practices, and Key Limitations

Understanding Indexing in SharePoint

Indexing in SharePoint is the process of analyzing, organizing, and making your content searchable so users can quickly find documents, list items, pages, and sites. Effective indexing in SharePoint boosts search relevance, speeds up queries, and enables features like metadata filtering, content discovery, and enterprise search.

What Is SharePoint Indexing?

At a high level, SharePoint uses crawlers and a search index to collect content and metadata from sites, lists, libraries, and files. The system extracts properties (like title, author, modified date, content type, and custom columns) and stores them in a searchable index. When users search, SharePoint matches the query against this index rather than scanning content in real time, resulting in faster, more relevant results.

How Indexing Works in Practice

  • Crawling: SharePoint periodically scans sites and content sources to discover new or updated items.
  • Property extraction: Metadata and text are parsed into crawled properties; relevant ones are mapped to managed properties that are searchable, refinable, and sortable.
  • Security trimming: Results respect permissions, ensuring users only see content they’re allowed to access.
  • Ranking and relevance: The search engine uses signals such as term frequency, metadata, and user interactions to rank results.

Types of Indexing Scenarios

  • List and library indexing: Indexing columns in large lists improves filter/sort performance and reduces query time.
  • Site and hub-level indexing: Enterprise search spans sites, hubs, and tenants for broad content discovery.
  • Hybrid or federated search: Organizations may combine SharePoint Online, on-premises SharePoint, and other sources via connectors.

Common Limitations and Constraints

  • Crawl frequency and delays: Changes aren’t indexed instantly. Depending on configuration and service load, new or updated content may take time to appear in search.
  • List performance thresholds: Very large lists can encounter performance limits when filtering/sorting non-indexed columns. Index key columns to avoid slow queries or timeouts.
  • Managed property governance: Not all crawled properties are automatically mapped. Creating additional managed properties may be restricted by admin policy and can take time to propagate.
  • File type and content parsing: Some file formats aren’t crawled or fully parsed. Password-protected or encrypted files typically can’t be indexed for content.
  • Permissions change latency: Updates to permissions might not be reflected in search results immediately due to indexing and cache refresh cycles.
  • Content size and limits: Extremely large documents or very large item counts can affect crawl success, indexing depth, and query performance.
  • Multi-geo and hybrid complexity: Disparate locations and mixed environments can introduce latency and inconsistent coverage if not configured correctly.

Best Practices to Improve SharePoint Indexing

  • Index key columns: For large lists/libraries, index frequently filtered columns (e.g., Status, Category, Modified).
  • Design metadata: Use consistent content types and site columns so critical fields can be mapped to managed properties.
  • Use managed properties for search: Query and refine on managed properties (e.g., Author, FileType) for reliable search-driven pages.
  • Keep structures clean: Avoid overly deep folder hierarchies; prefer metadata for classification to improve discoverability.
  • Monitor crawl logs: Review search/crawl reports to fix errors (unsupported formats, access issues, timeouts).
  • Plan for propagation: Expect delays after schema changes (new managed properties or mappings) and schedule updates during off-peak hours.
  • Secure appropriately: Use clear permission models to ensure accurate security trimming in results.

Step-by-Step Example: Index a Column in a SharePoint List

  • Go to the target list, open List settings.
  • Select Indexed columns and choose Create a new index.
  • Pick a frequently used filter column (e.g., Status or Department) and save.
  • Test by filtering the list or using a view that leverages the indexed column.

Example: Make a Custom Field Search-Friendly

  • Create a site column (e.g., ProjectCode) and add it to your content type.
  • Populate the field across documents and list items.
  • In the search schema (admin-controlled), map the crawled property for ProjectCode to a managed property configured as searchable/refinable.
  • After propagation, build a results page or filter panel that uses the managed property (e.g., RefinableString) to refine by ProjectCode.

Troubleshooting Tips

  • Content not appearing: Confirm the item is published/checked in and that the user has access; allow time for the next crawl/index update.
  • Property not searchable: Verify crawled-to-managed property mappings and confirm the managed property is marked as searchable/refinable/sortable as needed.
  • Slow queries on large lists: Add or adjust indexed columns and simplify views to reduce query complexity.
  • Unsupported files: Convert to supported formats or remove passwords to enable text extraction.

Key Takeaways

  • Indexing accelerates search and filtering across SharePoint content by leveraging metadata and managed properties.
  • Performance and freshness depend on crawl schedules, list design, and schema configuration.
  • Plan metadata, index critical columns, and monitor crawl health to minimize limitations and keep search relevant.

SharePoint Indexing: A Step-by-Step Guide for Faster Search and Precise Results

SharePoint indexing often fails silently, causing slow search and missing results. This guide shows exactly how to configure SharePoint indexing end-to-end—site settings, list-level indexing, search schema, and safe automation—so your users get fast, accurate results. Primary keyword: SharePoint indexing.

The Problem

Content updates are not discoverable, queries are slow, and filters return inconsistent items because lists aren’t indexed, sites aren’t reindexed, or managed properties are not mapped. You need a repeatable approach to fix indexing across sites and automate reindexing safely.

Prerequisites

  • Microsoft 365 tenant with SharePoint Online
  • PowerShell 7+ and PnP.PowerShell module (Install-Module PnP.PowerShell -Scope CurrentUser)
  • Role-based access (least privilege):
  • Site Owner or above for list/site indexing and reindex
  • Search Schema changes typically require SharePoint Administrator
  • Automation with app-only: Entra ID App with Sites.Selected + site-scoped permissions
  • Optional for automation: Azure Automation or Azure Functions with a System-Assigned Managed Identity

The Solution (Step-by-Step)

1) Confirm site-level indexing is allowed

Site Owners can check if content is visible to search crawlers.

  • Go to Site Settings → Search → Search and offline availability
  • Set Allow this site to appear in search results to Yes

Pro-Tip: If you changed this from No to Yes, trigger a site reindex to speed up propagation.

2) Index columns at the list/library level

Index columns used in filters, sorts, and query rules to avoid throttling and improve query performance.

  • Open your list/library → Settings → Indexed columns → Create a new index
  • Index only frequently queried columns (e.g., Status, Department, Created)

Pro-Tip: Avoid indexing lookup or multi-line rich text columns unless absolutely necessary; they can increase index size and crawl churn.

3) Reindex a list or library (targeted)

Use targeted reindex after column or schema changes on a specific list.

  • List Settings → Advanced settings → Reindex List

This flags the list for the next crawl so updated properties and new mappings are applied faster.

4) Reindex a site (broad fix)

Use this when you changed site-level search settings, content types, or many lists.

  • Site Settings → Search → Search and offline availability → Reindex site

Pro-Tip: Reindexing a site is heavier than a list reindex. Prefer list reindex when possible to reduce crawl load.

5) Map crawled properties to managed properties (search schema)

To make custom columns queryable/filterable/sortable, map crawled properties to managed properties with the right search attributes (Searchable, Queryable, Retrievable, Refinable, Sortable).

  • SharePoint Admin Center → More features → Search → Open
  • Manage Search Schema → Managed Properties
  • Create or edit a managed property (e.g., RefinableStringXX)
  • Map the relevant crawled property (e.g., ows_Status)

Pro-Tip: Use reserved RefinableStringXX or RefinableDateXX for facets and filters to avoid schema conflicts.

6) Automate reindex with PnP.PowerShell (interactive)

# Install PnP.PowerShell if needed
# Install-Module PnP.PowerShell -Scope CurrentUser

# 1) Interactive login for an admin or site owner
Connect-PnPOnline -Url "https://contoso.sharepoint.com/sites/ProjectA" -Interactive

# 2) Reindex a single list by title
# This sets the reindex flag so the next crawl refreshes properties
$web = Get-PnPWeb
$list = Get-PnPList -Identity "Documents"
Set-PnPList -Identity $list -NoCrawl:$false   # Ensure list is crawlable
Request-PnPReIndexList -Identity $list        # Mark list for reindex

# 3) Reindex the entire site (use sparingly)
Request-PnPReIndexWeb

# 4) Verify a column is indexed
# Returns indexed column definitions for the list
(Get-PnPField -List $list) | Where-Object { $_.Indexed -eq $true } | Select-Object InternalName, Title

Comments:

  • Request-PnPReIndexList and Request-PnPReIndexWeb mark content for recrawl.
  • Set-PnPList -NoCrawl:$false ensures the list is included in search.
  • Use least privilege: Site Owner is sufficient for list-level operations.

7) Secure automation with Managed Identity or app-only (no secrets)

For production jobs, avoid interactive auth and stored passwords. Use a Managed Identity (Azure Automation/Functions) or an Entra ID app with Sites.Selected and scoped permissions to specific sites.

# Option A: Managed Identity (runs inside Azure with System-Assigned MI)
# Prereqs:
# - Assign the Managed Identity Sites.Selected permissions and grant site-level rights
# - Use Grant-PnPAzureADAppSitePermission to scope access to the target site

# Connect using Managed Identity
Connect-PnPOnline -Url "https://contoso.sharepoint.com/sites/ProjectA" -ManagedIdentity

# Reindex specific list
Request-PnPReIndexList -Identity "Documents"
# Option B: Entra ID App with certificate (app-only, least privilege)
# Prereqs:
# - App registration with Microsoft Graph Sites.Selected (Application) permission
# - Admin consent granted
# - Grant site-level permission:
#   Grant-PnPAzureADAppSitePermission -AppId <CLIENT_ID> -DisplayName "Indexer" -Site "https://contoso.sharepoint.com/sites/ProjectA" -Permissions Read
# - Upload certificate and use its thumbprint

$tenant = "contoso.onmicrosoft.com"
$siteUrl = "https://contoso.sharepoint.com/sites/ProjectA"
$clientId = "00000000-0000-0000-0000-000000000000"
$thumb = "THUMBPRINT_HERE"

Connect-PnPOnline -Url $siteUrl -ClientId $clientId -Tenant $tenant -Thumbprint $thumb

# Safely trigger reindex
Request-PnPReIndexList -Identity "Documents"

Comments:

  • Sites.Selected lets you grant per-site permissions, enforcing least privilege.
  • Avoid legacy ACS app-only. Prefer Entra ID + Sites.Selected or Managed Identity.
  • No secrets in code; use certificates or Managed Identity.

8) Validate search consistency

  • Use Microsoft Search to query values you expect to find (e.g., Status:Active)
  • Validate refiners show the expected values (requires RefinableStringXX mapping)
  • Check list view performance with indexed columns applied as filters

Best Practices & Security

  • Principle of Least Privilege:
  • Day-to-day indexing: Site Owner
  • Search Schema: SharePoint Administrator (only when needed)
  • Automation: Managed Identity or app with Sites.Selected scoped to the target sites
  • Authentication:
  • Prefer Managed Identity in Azure Automation/Functions
  • Else use certificate-based app-only; avoid passwords and client secrets
  • Search Schema Hygiene:
  • Reuse RefinableStringXX/DateXX for facets and filters
  • Document managed property usage to prevent collisions across teams
  • Performance:
  • Index only columns that improve key queries
  • Prefer list reindex over site reindex to reduce crawl load

Pro-Tip: Create a small pilot list to test new mappings and reindex timings before applying to large libraries.

Troubleshooting

  • My column values don’t appear in search:
  • Confirm list is crawlable (NoCrawl = false)
  • Ensure a managed property is mapped and set to Queryable/Retrievable
  • Trigger Request-PnPReIndexList and wait for the next crawl cycle
  • Refiners don’t show my custom metadata:
  • Use a RefinableStringXX or RefinableDateXX managed property
  • Map the correct crawled property (often ows_ColumnInternalName)
  • App-only connection fails with 401/403:
  • Verify Sites.Selected consent and site-level grant (Grant-PnPAzureADAppSitePermission)
  • Confirm certificate thumbprint and validity
  • Reindex seems to do nothing:
  • Allow time for the next crawl; reindex sets a flag, it doesn’t force immediate recrawl
  • Check Service Health and Message Center for crawl incidents

Summary

  • Index the right columns and map to managed properties to make content queryable, refinable, and fast.
  • Use targeted list reindex first; reserve site reindex for broad changes.
  • Automate safely with Managed Identity or Sites.Selected app-only to enforce least privilege and avoid secrets.

References

Thursday, 22 January 2026

15 Free AI Apps for Daily Uses: Boost Productivity, Creativity, and Learning

Why Free AI Apps for Daily Uses Matter

Looking for Free AI apps for daily uses? The right tools can save time, automate routine tasks, and supercharge your creativity—without costing a cent. Below, you’ll find curated, reliable options with strong free tiers to help with writing, images, research, meetings, and more.

How to Choose the Best Free AI Apps

  • Clear value: The app should save measurable time or improve output quality.
  • Strong free tier: Generous limits or essential features available without paywalls.
  • Privacy and control: Transparent data practices and easy content export.
  • Cross-platform access: Works on web and mobile for on-the-go productivity.
  • Low learning curve: Simple onboarding with quick wins in minutes.

Top Free AI Apps by Category (With Examples)

1) Writing, Editing, and Communication

  • Grammarly (Free): Real-time grammar, tone, and clarity suggestions for emails, docs, and web forms.
  • QuillBot (Free): Paraphrasing and summarizing to tighten drafts or generate alternatives.
  • Microsoft Copilot (Free): General-purpose AI writing and ideation for drafts, outlines, and emails.
  • ChatGPT (Free tier): Brainstorming, rewriting, and quick explanations for everyday writing tasks.

Example: Paste a rough email into Grammarly to fix tone and clarity, then use QuillBot to generate a shorter version for a quick mobile reply.

2) Research, Search, and Learning

  • Perplexity (Free): Answer-focused search with citations to speed up research.
  • Google Gemini (Free): Q&A, brainstorming, and quick code or math help.
  • Socratic by Google (Free): Snap a photo of homework problems for step-by-step guidance.
  • Photomath (Free): Scan math problems for explanations and solutions.

Example: Use Perplexity to get a concise overview of a topic with sources, then ask Gemini to create a quick study outline.

3) Meetings, Notes, and Organization

  • Otter.ai (Free tier): Record and transcribe meetings, auto-summarize key points.
  • Notion (Free) + AI trial: Organize projects, notes, and docs; AI features often available via trial or limited access.
  • Google Docs Voice Typing (Free): Dictate notes and to-dos hands-free.

Example: Record a team call with Otter.ai, grab the auto-summary, and paste action items into a Notion task list.

4) Images, Design, and Video

  • Canva (Free) with Magic tools: Quick designs with AI-assisted text-to-image and layout suggestions.
  • CapCut (Free): AI-powered auto-captions, background removal, and smart cuts for short videos.
  • PicsArt (Free tier): AI photo effects, background removals, and quick touch-ups.

Example: Use Canva to generate a social post template, then polish a short product clip in CapCut with auto-captions for accessibility.

5) Productivity and Everyday Tasks

  • Microsoft Copilot in Edge (Free): Summarize pages, compare products, and draft outlines alongside your browsing.
  • Google Keep (Free) + AI suggestions: Organize notes, lists, and reminders; pair with voice typing for speed.
  • Trello (Free) with Butler automations: Automate simple task flows like due-date rules and checklists.

Example: While shopping online, use Copilot to summarize reviews; add a prioritized to-do list in Trello that auto-assigns due dates.

Quick Start: 10-Minute Daily AI Workflow

  • 2 min: Plan your top three tasks with Google Keep or Notion.
  • 3 min: Draft a key email using ChatGPT or Copilot; refine with Grammarly.
  • 3 min: Summarize one article or report in Perplexity for fast insights.
  • 2 min: Create a quick social image in Canva or edit a clip in CapCut.

Best Practices to Get More from Free AI Tools

  • Be specific: Provide context, objective, and constraints when prompting.
  • Iterate fast: Ask for outlines first, then expand; request alternatives.
  • Keep a template library: Save your best prompts and workflows for reuse.
  • Review critically: Verify facts, check tone, and ensure originality.
  • Mind privacy: Avoid uploading sensitive data to any tool; review settings.

Frequently Asked Questions

Are these truly free?

Yes—each app listed has a free tier. Some offer optional paid upgrades for higher limits or advanced features.

Can I use them for work?

Absolutely. Many teams use these free tiers to prototype, draft, and streamline workflows before upgrading.

Which should I start with?

For general use: ChatGPT or Copilot (writing), Grammarly (polish), Perplexity (research), Otter.ai (meetings), Canva or CapCut (creative), and Google Keep or Trello (tasks).

The Bottom Line

Free AI apps can handle daily writing, research, meetings, visuals, and planning with surprising quality. Start small, combine a few tools into a repeatable workflow, and you’ll reclaim hours every week—without spending a dime.

Gen AI vs Agentic AI vs AI Agent: Clear Differences, Use Cases, and When to Use Each

Gen AI vs Agentic AI vs AI Agent: What’s the Difference?

The phrase Gen AI vs Agentic AI vs AI Agent often confuses teams evaluating AI solutions. In short, Gen AI focuses on creating content and predictions, Agentic AI adds autonomous goal-directed behavior (planning, tool use, and feedback loops), and an AI Agent is a concrete implementation of agentic capabilities for a specific task or workflow.

Core Definitions

What is Generative AI (Gen AI)?

Generative AI uses models (often large language models or diffusion models) to generate text, images, audio, or code based on patterns learned from data. It excels at content creation, summarization, Q&A, and pattern-driven suggestions.

  • Strengths: Fast content generation, broad generalization, low setup overhead.
  • Limitations: Limited autonomy, no inherent memory of multi-step goals, needs guardrails for accuracy and compliance.

What is Agentic AI?

Agentic AI extends Gen AI with autonomy. It can plan multi-step tasks, call tools or APIs, reason over results, and iterate through feedback loops to achieve goals without constant human prompts.

  • Strengths: Goal-driven planning, tool integration, self-reflection loops, can handle workflows end-to-end.
  • Limitations: Higher complexity, monitoring required, needs robust evaluation and safety controls.

What is an AI Agent?

An AI Agent is a practical implementation of agentic behavior for a defined role, environment, and toolset. Think of it as an “autonomous digital worker” configured for a specific domain.

  • Strengths: Task specialization, measurable SLAs, easier governance within scoped boundaries.
  • Limitations: Narrower scope than general models, upfront configuration and integration work.

How They Work: Architecture at a Glance

Generative AI Architecture

  • Core model: LLM or diffusion model
  • Prompting: Instruction, context, and examples
  • Optional retrieval: RAG for grounding with enterprise data

Agentic AI Architecture

  • Planner: Breaks a goal into steps
  • Tooling: API calls, databases, search, actions
  • Memory: Short-/long-term context for iterative improvement
  • Executor: Runs steps, evaluates outcomes, retries or escalates

AI Agent Architecture

  • Role definition: Clear objectives and operating constraints
  • Environment: Specified tools, permissions, and data sources
  • Policies: Guardrails, compliance rules, and audit logging
  • Metrics: Success criteria, quality checks, and monitoring

Practical Examples

Generative AI Examples

  • Marketing: Draft blog posts, social captions, product descriptions.
  • Support: Summarize tickets and suggest knowledge base answers.
  • Engineering: Generate boilerplate code, unit tests, and documentation.

Agentic AI Examples

  • Sales Ops: Plan outreach, fetch CRM data via API, craft emails, and schedule follow-ups with iterative improvements.
  • Procurement: Compare vendor quotes, check policy rules, request clarifications, and recommend an award decision.
  • Data Ops: Diagnose pipeline failures, query logs, attempt fixes, and verify with validation checks.

AI Agent Examples

  • Customer Support Agent: Authenticates user, retrieves account data, proposes resolution, triggers a refund API, and documents the interaction.
  • Finance Reconciliation Agent: Pulls transactions, matches records, flags exceptions, and drafts a reconciliation report.
  • Recruiting Agent: Screens resumes, ranks candidates, schedules interviews, and updates the ATS with notes.

When to Use Gen AI vs Agentic AI vs AI Agents

  • Choose Generative AI when you need rapid content creation, ideation, summarization, or interactive Q&A with limited workflow complexity.
  • Choose Agentic AI when tasks require planning, tool/API calls, and iterative reasoning across multiple steps.
  • Choose AI Agents when you want a reliable, role-specific autonomous solution with clear guardrails, integrations, and SLAs.

Benefits and Risks

Benefits

  • Efficiency: Reduce manual effort and cycle times.
  • Consistency: Standardize outputs and processes.
  • Scalability: Run many tasks simultaneously without headcount growth.

Risks and Mitigations

  • Hallucinations: Use retrieval grounding, validation checks, and human-in-the-loop for critical steps.
  • Security/Privacy: Enforce least-privilege access, redact sensitive data, and log all actions.
  • Compliance: Embed policy prompts, approval gates, and audit trails.

Evaluation Checklist

  • Task clarity: Is the goal well-defined with measurable outcomes?
  • Data readiness: Are sources trusted, accessible, and governed?
  • Tooling: What APIs/actions are required and permitted?
  • Guardrails: What policies, constraints, and escalation paths exist?
  • Metrics: Define accuracy, latency, cost, and success thresholds.

Quick Comparison

  • Generative AI: Content and predictions; minimal autonomy.
  • Agentic AI: Adds planning, tool use, and iterative reasoning.
  • AI Agent: A deployed, role-specific agentic system with integrations and policies.

Getting Started

  • Pilot with Gen AI: Identify high-value content and summarization tasks.
  • Evolve to Agentic: Add tool calls for retrieval, search, and simple actions.
  • Operationalize as AI Agents: Define roles, permissions, safeguards, and monitoring to scale.

Copilot Studio in 2026: Features, Use Cases, and Best Practices to Build Enterprise-Ready AI Assistants

Copilot Studio in 2026: What It Is and Why It Matters

Copilot Studio in 2026 represents a powerful, low-code environment for designing, building, and managing AI copilots that streamline workflows, improve customer experiences, and boost productivity across the enterprise. By combining conversational design, workflow orchestration, data connectivity, and governance, it helps teams ship secure, scalable assistants faster.

Key Capabilities to Look For

  • Low-code conversational design: Visual builders for intents, entities, and dialog flows, plus tools to ground responses in your content.
  • Workflow automation: Trigger business processes, call APIs, and orchestrate approvals from within conversations.
  • Data connectivity: Connect to files, knowledge bases, and business apps to deliver contextual answers.
  • Prompt management: Centralize prompts, variants, and testing for consistent, high-quality outputs.
  • Guardrails and governance: Content filters, access controls, auditing, and monitoring for safe, compliant deployments.
  • Analytics and iteration: Track usage, identify gaps, and continuously improve with data-driven insights.

High-Impact Use Cases

  • Customer support: Deflect FAQs, resolve common issues, and escalate seamlessly to human agents.
  • IT and HR helpdesk: Automate password resets, provisioning, benefits queries, and policy guidance.
  • Sales enablement: Generate call summaries, recommend next steps, and pull CRM insights in context.
  • Operations: Standardize SOP access, automate incident intake, and accelerate approvals.
  • Knowledge access: Turn documentation and wikis into conversational, verified answers.

Example: Building a Support Copilot

1) Grounding and knowledge

Connect your product guides, release notes, and troubleshooting docs. Enable retrieval so the copilot cites the most relevant passages for transparency.

2) Conversation design

Define intents like “track order,” “reset password,” and “return item.” Add entity extraction for order IDs or emails. Provide step-by-step responses with confirmation prompts.

3) Actions and integrations

Attach authenticated actions to look up orders, create tickets, and initiate returns. Use role-based access to control who can trigger sensitive operations.

4) Safety and policies

Configure content moderation and data loss prevention rules. Limit answers to your verified knowledge base and log escalations for auditability.

5) Testing and improvement

Run sandbox conversations, measure resolution rate and CSAT, and iterate prompts and flows based on analytics.

Best Practices for Enterprise Readiness

  • Start small, scale fast: Launch with one high-value scenario, then expand to adjacent tasks.
  • Ground in trusted data: Use verified sources, citations, and guardrails to prevent hallucinations.
  • Design for handoff: Provide clear routes to human agents with full context and conversation transcripts.
  • Secure by default: Enforce least-privilege access, encryption, and scoped credentials for actions.
  • Measure what matters: Track containment, time-to-resolution, and user satisfaction—not just deflection.
  • Operationalize updates: Version prompts, review changes, and schedule content refreshes.
  • Accessibility and inclusivity: Support multiple languages, clear language, and consistent UX patterns.

Optimization Tips for Faster, Better Results

  • Prompt patterns: Use structured prompts with roles, constraints, and examples to improve reliability.
  • Response constraints: Limit output formats for downstream automations, like JSON snippets or bullet summaries.
  • Context windows: Keep inputs concise and relevant; prefer links to full documents with targeted retrieval.
  • Caching and fallbacks: Cache frequent answers and define fallbacks for ambiguous queries.
  • A/B experimentation: Test prompt variants and flows to find the best-performing experiences.

Compliance, Governance, and Risk Management

  • Data residency and retention: Align with regional requirements and minimize stored conversation data.
  • PII handling: Mask sensitive fields and restrict exposure in logs and analytics.
  • Human oversight: Periodic reviews of conversations, escalation outcomes, and content drift.
  • Change management: Document updates, approvals, and rollback procedures for critical prompts and actions.

Real-World Example Flows

Order status

User provides email and order ID. Copilot validates, fetches status via API, and offers delivery ETA with options to reschedule or escalate.

Employee onboarding

Copilot collects role, location, and start date, triggers account creation, equipment requests, and sends a welcome checklist.

Incident intake

Structured questions gather severity, impact, and reproduction steps; copilot files a ticket and notifies the on-call channel.

The Road Ahead

As organizations standardize on AI platforms, Copilot Studio in 2026 is positioned to unite conversations, content, and actions under strong governance. Teams that invest in clear use cases, safe integrations, and continuous improvement will unlock measurable gains in efficiency, satisfaction, and time-to-value.

Bind dropdown list in property pane spfx


Prerequisite:

Make sure installation of spfx is already done and we are using pnp to access the SharePoint lists from current site so make sure pnp is also installed.

How to bind property pane Dropdown list in Client side webpart in SharePoint Framework.

We have a scenario suppose that we have to bind a dropdown list with current site’ s lists/libraries.
 Just need to follow below instruction step by step  
1.       Create a Solution  .
2.       Add a Webpart to the solution.
3.       Declare the property pane  “PropertyPaneDropdown” for dropdown list.

import {
  BaseClientSideWebPart,
  IPropertyPaneConfiguration,
  PropertyPaneDropdown,
} from '@microsoft/sp-webpart-base';

4.       Come to the property pane under “getPropertyPaneConfiguration”.
5.       Define your own group of property pane or leave  the default and add under existing group fields.
protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration {
    return {
      pages: [
        {
          header: {
            description: strings.PropertyPaneDescription
          },
          groups: [
            {
              groupName: strings.BasicGroupName,
              groupFields: [
                PropertyPaneDropdown('dropdownLists', {
                  label: "Lists",
                  options:this._dropdownOptions,
                  disabled:this.listsDropdownDisabled
                })
              ]
            }
          ]
        }
      ]
    };
  }

6.       Declare Interface “IPropertyPaneDropdownOption”  and “IODataList” to map the dropdown list with the list
                  
                        export interface IPropertyPaneDropdownOption
{
  key:string;
text:string;
}
export interface IODataList
{
  Id:string;
 Title:string;
}
7.       Define two variables for dropdown option and to disable the dropdown while lists loading just below the .
      
export default class HellowWebpartWebPart extends BaseClientSideWebPart<IHellowWebpartWebPartProps> {

         private _dropdownOptions: IPropertyPaneDropdownOption[];
  private listsDropdownDisabled: boolean = true;

8.       Now override the existing method onPropertyPaneConfigurationStart() and paste the below code

protected onPropertyPaneConfigurationStart(): void
  {
    //Bind DropDown List in Peropert pane
    this.listsDropdownDisabled = !this._dropdownOptions;
    if (this._dropdownOptions)
    {
      return;
    }
      this.context.statusRenderer.displayLoadingIndicator(this.domElement, '_dropdownOptions');
      pnp.sp.web.lists.get()
      .then((listOptions: IODataList[]): void =>
      {
          var options: Array<IPropertyPaneDropdownOption> = new Array<IPropertyPaneDropdownOption>();
          listOptions.map((list: IODataList) => {
          options.push( { key: list.Id, text: list.Title });
      });
        this._dropdownOptions=options
        this.listsDropdownDisabled = false;
        this.context.propertyPane.refresh();
        this.context.statusRenderer.clearLoadingIndicator(this.domElement);
        this.render();
      });
  }

9.       Start terminal and run gulp bundle
10.   Now run the gulp serve –nobrowser command in terminal
11.   Open workbench on the site open direct link https://tenant.sharepoint.com/sites/demo/_layouts/15/workbench.aspx
12.   Add client side webpart on the bench.
13.   Click on Edit properties
14.   You see on  right side in properties will be dropdown list bind with current site’s lists/libraries

Happy coding  !!!


The Future of AI Agent Technology: Trends, Use Cases, and What Comes Next

The Future of AI Agent: What It Means for Work and Innovation

The Future of AI Agent is unfolding rapidly, redefining how businesses automate tasks, scale decision-making, and deliver personalized experiences. As autonomous systems become more capable, they will transform industries by combining reasoning, tool use, and collaboration at scale.

What Is an AI Agent and Why It Matters

An AI agent is a goal-driven system that can perceive context, reason about tasks, take actions (often via tools or APIs), and learn from feedback. Unlike simple chatbots, modern agents orchestrate multi-step workflows, integrate with enterprise data, and adapt to changing objectives.

  • Autonomous execution: Plan, act, and verify with minimal human oversight.
  • Tool integration: Trigger APIs, databases, SaaS apps, and internal systems.
  • Memory and learning: Improve performance from outcomes and feedback.

Key Trends Shaping the Future

  • Multi-agent collaboration: Specialized agents (researcher, planner, builder, reviewer) will coordinate to solve complex, cross-functional tasks.
  • Enterprise-grade governance: Policy, permissioning, and auditability will become standard for safe and compliant deployments.
  • Agentic UX: Interfaces will shift from point-and-click to goal-setting, where users describe outcomes and agents execute.
  • Real-time reasoning: Agents will adapt to streaming data from apps, sensors, and user interactions.
  • Offline and on-device: Edge models will enable private, low-latency decisions without sending data to the cloud.

High-Impact Use Cases

Customer Support and Success

Agents can triage tickets, retrieve knowledge, generate replies, and escalate with full context. They reduce resolution time and maintain consistent tone and policy compliance.

Software Engineering Copilots

Development agents can generate specs, write tests, open pull requests, run CI checks, and request reviews. A reviewer agent can verify performance and security before merging.

Sales and Marketing Automation

Agents qualify leads, personalize outreach, schedule meetings, and update CRM entries. They can run experiments and optimize campaigns across channels.

Operations and Finance

Agents reconcile invoices, flag anomalies, generate reports, and enforce spend policies using rule checks and anomaly detection.

Architecture of Modern AI Agents

  • Planner: Breaks goals into actionable steps.
  • Executor: Calls tools, APIs, and services.
  • Critic/Verifier: Checks outputs against constraints and metrics.
  • Memory: Stores context, preferences, and outcomes for future runs.
  • Guardrails: Enforces policies, PII handling, and compliance requirements.

Design Principles for Reliable Agent Systems

  • Goal clarity: Define objectives, constraints, and success metrics before execution.
  • Deterministic tools: Prefer idempotent, well-typed APIs with explicit error handling.
  • Human-in-the-loop: Require approvals for high-risk actions (payments, code merges, customer escalations).
  • Observability: Log steps, decisions, tool calls, and outcomes for auditing and debugging.
  • Evaluation: Use sandboxed simulations and benchmark tasks to measure reliability and safety.

Examples You Can Implement Today

Example 1: Knowledge Assistant for Support

  • Goal: Reduce average handle time.
  • Flow: Planner identifies intent → Executor searches KB and tickets → Critic checks policy → Draft reply for human review.
  • Tools: Search API, ticketing system, style/policy checker.

Example 2: PR Creation and Review Agent

  • Goal: Automate routine fixes.
  • Flow: Detect issue → Generate patch and tests → Open PR → Reviewer agent validates with CI → Human approves.
  • Tools: Repo API, test runner, CI logs, security scanner.

Example 3: Finance Reconciliation Agent

  • Goal: Catch discrepancies early.
  • Flow: Ingest statements → Match transactions → Flag anomalies → Summarize for accounting.
  • Tools: Banking API, rules engine, alerting system.

Risks and How to Mitigate Them

  • Hallucinations: Use retrieval augmentation, citations, and verifier agents.
  • Security: Apply least-privilege credentials, scoped tokens, and secret rotation.
  • Compliance: Redact PII, maintain audit trails, and configure data residency.
  • Runaway actions: Set budgets, step limits, and approval gates.

Measuring Agent Performance

  • Task success rate: Percentage of goals completed within constraints.
  • Cost and latency: Spend per task and average time to completion.
  • Quality: Human ratings, policy adherence, and error rates.
  • Trust signals: Coverage of tests, number of verified steps, and rollback frequency.

What’s Next for the Future of AI Agent

Agent ecosystems will become interoperable, enabling secure marketplaces of specialized agents that compose and negotiate with each other. With stronger reasoning, transparent governance, and robust evaluations, organizations will move from pilot projects to production-scale automation that compounds productivity across teams.

The winners will focus on clear goals, safe architectures, measurable outcomes, and continuous iteration—turning agents from demos into dependable digital teammates.

Add ,Edit and Delete in GridView with People picker and DateTime Picker control

Add ,Edit and Delete in GridView with People picker and DateTime Picker control

using System;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using System.Data;
using System.IO;
using System.Collections;
namespace CustomPageForLibrary.Layouts.CustomPageForLibrary
{
    public partial class TaskFormForLirary : LayoutsPageBase
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                DropDownBind();
                BindData();
             
             
            }
        }
        protected void GridView1_RowEditing(object sender, GridViewEditEventArgs e)
        {
           
            GridView1.EditIndex = e.NewEditIndex;
            BindData();
        }
        protected void GridView1_RowUpdating(object sender, GridViewUpdateEventArgs e)
        {
            int i = e.RowIndex;

            //using (SPSite site = new SPSite("siteurl"))
            using (SPSite site = new SPSite(SPContext.Current.Web.Url))
            {
                site.AllowUnsafeUpdates = true;
                using (SPWeb web = site.OpenWeb())
                {
                    web.AllowUnsafeUpdates = true;
                    SPList list = web.Lists["MOMListt"];
                    int id = Convert.ToInt32(GridView1.DataKeys[e.RowIndex].Value);
                    SPListItem item = list.GetItemById(id);
               
                  //  item["Meeting"] = new SPFieldLookupValue(Convert.ToInt32(txtMeetingId.Text),txtMeetingName.Text);
                    item["Minutes"] = ((TextBox)GridView1.Rows[i].FindControl("txtMinutes")).Text;
                    PeopleEditor ppAuthor = ((PeopleEditor)GridView1.Rows[i].FindControl("ActionByUser"));
                    PickerEntity ActionUser = (PickerEntity)ppAuthor.ResolvedEntities[0];
                    SPUser actionByUser = Web.EnsureUser(ActionUser.Key);
                    item["Actionby"] = actionByUser;
                    if (((DateTimeControl)GridView1.Rows[i].FindControl("targetdateuser")).SelectedDate.Date.ToString() != "" || ((DateTimeControl)GridView1.Rows[i].FindControl("targetdateuser")).SelectedDate.Date.ToString() !=null)
                    {
                    item["TargetDate"] = ((DateTimeControl)GridView1.Rows[i].FindControl("targetdateuser")).SelectedDate.Date;
                    }
                    item["Status"] = ((DropDownList)GridView1.Rows[i].FindControl("DropDownList1")).SelectedItem.Text;
                    CheckBox chk = ((CheckBox)GridView1.Rows[i].FindControl("Assigned"));
                    string blActive = "";
                    if (chk.Checked == true)
                    {
                        blActive = "True";
                        item["assignedtask"] = blActive;
                    }
                    else
                    {
                        blActive = "False";
                        item["assignedtask"] = blActive;
                    }
                    item["Issues"] = TextBox7.Text;
                    item.Update();
                    web.AllowUnsafeUpdates = false;
                }
                site.AllowUnsafeUpdates = false;

            }
            GridView1.EditIndex = -1;
            BindData();
        }
        protected void GridView1_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            DataRowView drview = e.Row.DataItem as DataRowView;
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                if ((e.Row.RowState & DataControlRowState.Edit) > 0)
                {
                    SPSite site = new SPSite(SPContext.Current.Web.Url);
                    SPWeb web = site.OpenWeb();
                    PeopleEditor pplEditor = ((PeopleEditor)e.Row.FindControl("ActionByUser"));
                    ArrayList alApprover = new ArrayList();
                    PickerEntity pentApprover = new PickerEntity();
                    char[] delimiterChars = { '#' };
                    string text = drview[2].ToString();
                    string[] words = text.Split(delimiterChars);
                    pentApprover.Key = words[1];
                    alApprover.Add(pentApprover);
                    pplEditor.UpdateEntities(alApprover);
                    DateTimeControl dtc = ((DateTimeControl)e.Row.FindControl("targetdateuser"));
                    dtc.SelectedDate=Convert.ToDateTime(drview[3].ToString());
                    DropDownList dpEmpdept = (DropDownList)e.Row.FindControl("DropDownList1");
                    DataTable dt = GetStatus();
                    dpEmpdept.DataSource = GetStatus();
                    dpEmpdept.DataTextField = "DepName";
                    dpEmpdept.DataValueField = "DepName";
                    dpEmpdept.DataBind();
                    dpEmpdept.SelectedValue = drview[4].ToString();
                    CheckBox chkb = (CheckBox)e.Row.FindControl("Assigned");
                    if (drview[5].ToString() == "True")
                    { chkb.Checked = true; }
                    else { chkb.Checked = false; }
             
                }
            }
            if (e.Row.RowType == DataControlRowType.Footer)
            {
                DropDownList dp = (DropDownList)e.Row.FindControl("DropDownList14");
                dp.DataSource = GetStatus();
                dp.DataTextField = "DepName";
                dp.DataValueField = "DepName";
                dp.DataBind();
            }
        }
        private DataTable GetStatus()
        {
           
            DataTable dt = new DataTable();
            dt.Columns.Add("DepName");
            DataRow rw1 = dt.NewRow();
            rw1[0] = "Open";
            dt.Rows.Add(rw1);
            DataRow rw2 = dt.NewRow();
            rw2[0] = "Closed";
            dt.Rows.Add(rw2);
            return dt;
        }
        protected void GridView1_RowCancelingEdit(object sender, GridViewCancelEditEventArgs e)
        {
            GridView1.EditIndex = -1;

            BindData();

        }
        protected void GridView1_RowDeleting(object sender, GridViewDeleteEventArgs e)
        {
            int i = e.RowIndex;
           // BindData();
        }
        public void BindData()
        {
            using (SPSite s = new SPSite(SPContext.Current.Web.Url))
            {
                using (SPWeb sw = s.OpenWeb())
                {
                    SPList sl = sw.Lists["MOMListt"];
                    SPQuery query=new SPQuery();
                    if (txtMeetingId.Text != "")
                    {
                        query.Query = @"<Where>" +
          "<Eq>" +
             "<FieldRef Name='Meeting' LookupId='True' />" +
             "<Value Type='Lookup'>" + Convert.ToInt32(txtMeetingId.Text) + "</Value>" +
          "</Eq>" +
       "</Where>";
                    }
                    SPListItemCollection itemCollection = sl.GetItems(query);
                    DataTable ResTable = new DataTable();
                    ResTable.Columns.Add(new DataColumn("ID"));
                    ResTable.Columns.Add(new DataColumn("Minutes"));
                    ResTable.Columns.Add(new DataColumn("Actionby"));
                    ResTable.Columns.Add(new DataColumn("TargetDate"));
                    ResTable.Columns.Add(new DataColumn("Status"));
                    ResTable.Columns.Add(new DataColumn("TaskAssigned"));
               
                    foreach (SPListItem item in itemCollection)
                    {
                        DataRow dr = ResTable.NewRow();
                        dr["ID"] = item["ID"].ToString();
                        dr["Minutes"] = item["Minutes"];
                        dr["ActionBy"] = item["Actionby"].ToString();
                        dr["TargetDate"] = item["TargetDate"];
                        dr["Status"] = item["Status"].ToString();
                        dr["TaskAssigned"] = item["assignedtask"].ToString();
                        ResTable.Rows.Add(dr);
                    }
                    if (ResTable.Rows.Count > 0)
                    {
                        GridView1.DataSource = ResTable;
                        GridView1.DataBind();
                     
                    }
                    else
                    {
                        DataRow dr = ResTable.NewRow();
                        dr["ID"] = "";
                        dr["Minutes"] = "";
                        dr["ActionBy"] = "";
                        dr["TargetDate"] = "";
                        dr["Status"] = "";
                        dr["TaskAssigned"] = "";
                        ResTable.Rows.Add(dr);
                        GridView1.DataSource = ResTable;
                        GridView1.DataBind();
                    }
                 
                }
            }
        }
     
       
        public void DropDownBind()
        {
            using (SPSite site = new SPSite(SPContext.Current.Web.Url))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    DataSet ds = new DataSet();
                    SPList list = web.Lists["Board Events"];
                    SPListItem item = list.Items.GetItemById(Convert.ToInt32(Request.QueryString["Mid"].ToString()));
                    txtMeetingName.Text = item["Title"].ToString();
                    txtMeetingId.Text = item["ID"].ToString();
                 
                }
            }
        }
     
        protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            if (e.CommandName == "Add")
            {
                using (SPSite site = new SPSite(SPContext.Current.Web.Url))
                {
                    site.AllowUnsafeUpdates = true;
                    using (SPWeb web = site.OpenWeb())
                    {
                        web.AllowUnsafeUpdates = true;
                        SPList list = web.Lists["MOMListt"];
                        SPListItem item = list.Items.Add();
                        item["Meeting"] = new SPFieldLookupValue(Convert.ToInt32(txtMeetingId.Text), txtMeetingName.Text);
                        item["Minutes"] = ((TextBox)GridView1.FooterRow.FindControl("txtMinuteFooter")).Text;
                        PeopleEditor ppAuthor = ((PeopleEditor)GridView1.FooterRow.FindControl("ActionBy"));
                        PickerEntity ActionUser = (PickerEntity)ppAuthor.ResolvedEntities[0];
                        SPUser actionByUser = Web.EnsureUser(ActionUser.Key);
                        item["Actionby"] = actionByUser;
                        item["TargetDate"] = ((DateTimeControl)GridView1.FooterRow.FindControl("targetdate")).SelectedDate.Date;
                        item["Status"] = ((DropDownList)GridView1.FooterRow.FindControl("DropDownList14")).SelectedItem.Text;
                        CheckBox chk = ((CheckBox)GridView1.FooterRow.FindControl("AssignedFilter"));
                        string blActive = "";
                        if (chk.Checked == true)
                        {
                            blActive = "True";
                            item["assignedtask"] = blActive;
                        }
                        else
                        {
                            blActive = "False";
                            item["assignedtask"] = blActive;
                        }
                        if (TextBox7.Text != "")
                        {
                            item["Issues"] = TextBox7.Text;
                        }
                        item.Update();
                        web.AllowUnsafeUpdates = false;
                    }
                    site.AllowUnsafeUpdates = false;
               
                }
                BindData();
            }
            else if (e.CommandName == "Delete")
         {
             using (SPSite site = new SPSite(SPContext.Current.Web.Url))
           {
                site.AllowUnsafeUpdates = true;
                using (SPWeb web = site.OpenWeb())
                {
                    web.AllowUnsafeUpdates = true;
                 
                    SPList taskList = web.Lists["Tasks"];
                    SPQuery query = new SPQuery();
                    query.Query = @"<Where>" +
         "<Eq>" +
            "<FieldRef Name='MinuteofMeetingId'/>" +
            "<Value Type='Number'>" + Convert.ToInt32(e.CommandArgument.ToString()) + "</Value>" +
         "</Eq>" +
      "</Where>";

                    SPListItemCollection itemcollection = taskList.GetItems(query);

                    for (int i = itemcollection.Count - 1; i >= 0; i--)
                    {
                        SPListItem item = itemcollection[i];
                        item.Delete();
                    }
                    SPList list = web.Lists["MOMListt"];
                    list.Items.DeleteItemById(Convert.ToInt32(e.CommandArgument.ToString()));
                    web.AllowUnsafeUpdates = false;
                }
                site.AllowUnsafeUpdates = false;
           }
             BindData();
             
        }
         

        }
     

       
    }
}


HTML Code///////////////////////////////////////////////////////////////////////////////////////////////
<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %>
<%@ Import Namespace="Microsoft.SharePoint.ApplicationPages" %>
<%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register Tagprefix="asp" Namespace="System.Web.UI" Assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" %>
<%@ Import Namespace="Microsoft.SharePoint" %>
<%@ Assembly Name="Microsoft.Web.CommandUI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="TaskFormForLirary.aspx.cs" Inherits="CustomPageForLibrary.Layouts.CustomPageForLibrary.TaskFormForLirary" DynamicMasterPageFile="~masterurl/default.master" %>

<asp:Content ID="PageHead" ContentPlaceHolderID="PlaceHolderAdditionalPageHead" runat="server">
<style type="text/css">
        #DivContent
        {
            margin-top: 30px;
            width: 85%;
            border: .1em;
            border-style: none;
            padding: 15px;
        }
        table
        {
            width: 100%;
        }
        .ControlTD
        {
            width: 20%;
            text-align: left;
        }
        .TextTD
        {
            width: 25%;
            font-size: 12px;
            text-align: left;
            color: #00A1DE;
        }
        .RFVTD
        {
            width: 10%;
            text-align: left;
        }
        p
        {
            text-align: center;
            font-size: 22px;
            color: #3C8A2E;
        }
    </style>
    <script language="javascript" type="text/javascript">

        function ValidateGrid(x) {

            var gridView = document.getElementById('<%=GridView1.ClientID %>');

            var selectedRowIndex = x.parentNode.parentNode.rowIndex;

            var txtName = gridView.rows[parseInt(selectedRowIndex)].cells[0].children[0];

             var pplpicker = gridView.rows[parseInt(selectedRowIndex)].cells[1].children[0];

            if (txtName.value == "" || pplpicker.value=="")
            {

                alert('Please input all required fields');

                return false;

            }

        }

    </script>
</asp:Content>

<asp:Content ID="Main" ContentPlaceHolderID="PlaceHolderMain" runat="server">

<div id="DivContent">
        <p>
            Minutes of Meeting</p>
            <div><div>&nbsp; Meeting&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
               <%-- <asp:DropDownList ID="DropDownList2" runat="server" style="margin-left: 0px" Width="309px">
                </asp:DropDownList>--%>
                <asp:Label ID="txtMeetingName" runat="server"  Font-Bold="true">
                </asp:Label><asp:Label ID="txtMeetingId" runat="server"
                     ForeColor="White"></asp:Label>
                   
                </div></div>
                <asp:UpdatePanel ID="Panel" runat="server" >
            <ContentTemplate>
            <br />
            <br />
         <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="False" DataKeyNames="ID"
    EnableModelValidation="True" ShowFooter="True" OnRowEditing="GridView1_RowEditing" OnRowCancelingEdit="GridView1_RowCancelingEdit" OnRowCommand="GridView1_RowCommand" OnRowDeleting="GridView1_RowDeleting" OnRowUpdating="GridView1_RowUpdating" OnRowDataBound="GridView1_RowDataBound"  >
    <Columns>
        <asp:TemplateField HeaderText="Minutes">
            <EditItemTemplate>
                <asp:TextBox ID="txtMinutes" runat="server" Text='<%#Eval("Minutes")%>' TextMode="MultiLine" Width="350px" Height="70px"></asp:TextBox>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label1" runat="server" Text='<%#Eval("Minutes")%>'></asp:Label>
            </ItemTemplate>
            <FooterTemplate>
         <asp:TextBox ID="txtMinuteFooter" runat="server" TextMode="MultiLine" Width="350px" Height="70px"></asp:TextBox>
     
        </FooterTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Action By">
            <EditItemTemplate>
                <SharePoint:PeopleEditor ID="ActionByUser" runat="server" MultiSelect="false" Width="200px" AllowEmpty="false"  />
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label2" runat="server" Text='<%#Eval("ActionBy")%>'></asp:Label>
            </ItemTemplate>
            <FooterTemplate>
                 <SharePoint:PeopleEditor ID="ActionBy" runat="server" MultiSelect="false" Width="200px" AllowEmpty="false"  />
        </FooterTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Target Date" ItemStyle-Width="150px">
            <EditItemTemplate>
           
                <SharePoint:DateTimeControl EnableViewState="true" ID="targetdateuser" runat="server"
                        DateOnly="true" />
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label3" runat="server" Text='<%#Eval("TargetDate")%>'></asp:Label>
            </ItemTemplate>
            <FooterTemplate>
                 <SharePoint:DateTimeControl EnableViewState="true" ID="targetdate" runat="server"
                        DateOnly="true" />
        </FooterTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Status">
            <EditItemTemplate>
                <asp:DropDownList ID="DropDownList1" runat="server">
             
               
                </asp:DropDownList>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label4" runat="server" Text='<%#Eval("Status")%>'></asp:Label>
            </ItemTemplate>
            <FooterTemplate>
         <asp:DropDownList ID="DropDownList14" runat="server">
             
                </asp:DropDownList>
        </FooterTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Assigned Task">
            <EditItemTemplate>
               <asp:CheckBox ID="Assigned" runat="server">
             
                </asp:CheckBox>
            </EditItemTemplate>
            <ItemTemplate>
              <asp:Label ID="Label5" runat="server" Text='<%#Eval("TaskAssigned")%>'></asp:Label>
           
           
            </ItemTemplate>
            <FooterTemplate>
         <asp:CheckBox ID="AssignedFilter" runat="server" >
                </asp:CheckBox>
        </FooterTemplate>
        </asp:TemplateField>
        <asp:TemplateField ShowHeader="False">
            <EditItemTemplate>
                <asp:LinkButton ID="LinkButton11" runat="server" CausesValidation="true" OnClientClick='javascript:return ValidateGrid(this);'
                    CommandName="Update" Text="Update" CommandArgument='<%#Eval("ID")%>'></asp:LinkButton>
                &nbsp;<asp:LinkButton ID="LinkButton2" runat="server" CausesValidation="False"
                    CommandName="Cancel" Text="Cancel"></asp:LinkButton>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="False"
                    CommandName="Edit" Text="Edit"></asp:LinkButton>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:TemplateField ShowHeader="False">
            <ItemTemplate>
         
                <asp:LinkButton ID="LinkButton2s" runat="server" CausesValidation="False"
                    CommandName="Delete" Text="Delete" CommandArgument='<%#Eval("ID")%>'></asp:LinkButton>

            </ItemTemplate>
            <FooterTemplate>
             <asp:LinkButton ID="LinkButton21" runat="server"
                    CommandName="Add" Text="Add" CausesValidation="true" OnClientClick='javascript:return ValidateGrid(this);'></asp:LinkButton>
            </FooterTemplate>
        </asp:TemplateField>

    </Columns>
 
</asp:GridView>
    </ContentTemplate>
    </asp:UpdatePanel>
<div>
    <table>
        <tr>
            <td valign="top">Pending Issues :</td><td>
                <asp:TextBox ID="TextBox7" runat="server" TextMode="MultiLine" Height="84px" Width="534px"></asp:TextBox></td>

        </tr>

    </table>

</div>
        <br />
        <p>
            &nbsp;</p>
    </div>

</asp:Content>

<asp:Content ID="PageTitle" ContentPlaceHolderID="PlaceHolderPageTitle" runat="server">
Application Page
</asp:Content>

<asp:Content ID="PageTitleInTitleArea" ContentPlaceHolderID="PlaceHolderPageTitleInTitleArea" runat="server" >
My Application Page
</asp:Content>