Development skills

Build FastAPI endpoints for creating, reading, updating, and deleting records. The skill guides authentication requirements, response models, HTTP status codes, and integration into an application using a reusable router template.

• Add endpoints for creating, reading, updating, and deleting records
• Require authentication for selected endpoints
• Define response models and HTTP status codes

Build Python workflows for Azure Blob Storage, a service for storing files and other unstructured data. Covers uploads, downloads, file listing, storage containers, metadata, and settings for large transfers.

• Upload and download files with Python
• List stored files by name prefix
• Manage file metadata and content types

Define Python data models with Pydantic v2, separating shared fields, creation requests, optional updates, responses, and database documents. Provides a template and examples for validating values and mapping Python field names to API names.

• Define separate API request and response models
• Make every field optional for partial updates
• Map snake_case fields to camelCase API names

Connect Node.js and TypeScript applications to Azure Database for PostgreSQL Flexible Server using pg. Implement queries, reusable database connections, transactions that group updates together, and passwordless authentication with Microsoft Entra ID.

• Connect an application to Azure PostgreSQL
• Reuse database connections with a pool
• Group related updates in a transaction

Implement secret storage and retrieval in Node.js applications with Azure Key Vault. Covers secret versions, expiration, deletion and recovery, plus examples for managing encryption keys, rotating them, and performing cryptographic operations.

• Storing and retrieving application secrets
• Managing secret versions and expiration
• Recovering accidentally deleted secrets

Build Rust applications that send and receive events through Azure Event Hubs. The skill covers batch sending, reading from partitions, which are separate event sequences, and choosing where reading starts.

• Send application events from Rust
• Send multiple events in batches
• Read events from a specific partition

Set up Azure authentication in JavaScript and TypeScript applications. Covers local developer sign-in, managed identities that avoid stored secrets, application credentials, and browser login, with examples for connecting Azure SDK clients.

• Set up Azure authentication for local development
• Use managed identity in production
• Authenticate an application with a secret or certificate

Implement file uploads, downloads, listing, and container management in Azure Blob Storage using JavaScript or TypeScript. Includes streaming for large files and time-limited access links for sharing or browser uploads.

• Add browser uploads to Azure Blob Storage
• Stream large files to cloud storage
• Create time-limited file sharing links

Create typed Zustand stores for shared React state. Separates stored values from update actions, uses selectors to read specific values, and supports subscriptions that watch selected changes outside React, with a template and integration steps.

• Create a shared state store for a React app
• Separate state types from update action types
• Limit rendering updates to selected values

Build JavaScript and TypeScript applications that send and receive events through Azure Event Hubs. Covers batched sending, partitions that divide event streams, saved processing positions for restarting consumers, and error handling for telemetry and real-time data ingestion.

• Collect IoT sensor telemetry
• Implement event ingestion for real-time analytics
• Send related events to the same partition

Build Azure Queue Storage message handling in JavaScript or TypeScript with @azure/storage-queue. Cover sending, receiving, inspecting, and deleting messages, plus temporary message hiding during processing, batch retrieval, and handling messages that repeatedly fail.

• Implementing queue message sending and receiving
• Building a worker that deletes messages after processing
• Extending message hiding time for long tasks

Implement Azure Cosmos DB data operations in JavaScript or TypeScript. Covers creating, reading, updating, and deleting documents, plus parameterized queries, pagination, bulk operations, and checks that prevent overwriting concurrent changes.

• Implement document creation, retrieval, updates, and deletion
• Build filtered queries with pagination
• Process multiple document operations in bulk

Write Python code to manage Azure API Management services, import API definitions, bundle APIs into products, and configure access. Examples cover subscriptions, request policies, backend services, and authentication with Azure credentials.

• Create an Azure API Management service with Python
• Import an API from an OpenAPI definition
• Bundle APIs into products and manage subscriptions

Implement cryptographic key management in TypeScript with Azure Key Vault. Covers key creation, encryption and decryption, digital signatures, scheduled key replacement, and backup and restore using the JavaScript SDK.

• Create and manage cryptographic keys
• Add encryption and decryption to an application
• Implement digital signatures and verification

Build search applications with Azure AI Search in TypeScript. Create searchable indexes, upload documents, combine keyword matching with vector search for similar meaning, and add relevance ranking, filters, and autocomplete.

• Creating and updating searchable document indexes
• Combining keyword search with searches for similar meaning
• Ranking natural language search results by relevance

Implement certificate management in Rust with the official Azure Key Vault library. Examples cover creating self-signed certificates, retrieving and updating certificates, listing results, and signing data with an associated key through the separate Keys SDK.

• Creating self-signed certificates from Rust
• Retrieving and updating certificates in Key Vault
• Listing certificates across paginated results

Implement message queues in Python with Azure Queue Storage to distribute tasks and process work asynchronously. Examples cover sending, receiving, inspecting, updating, and deleting messages, with timing controls and guidance for handling messages that repeatedly fail.

• Distribute queued tasks to processing workers
• Delay messages or set their expiration time
• Inspect waiting messages without hiding them

Build Rust code that stores and retrieves passwords, API keys, and connection strings in Azure Key Vault. Includes secret property updates, deletion, paginated listing, authentication choices, and error handling using the official Rust library.

• Store and retrieve API keys from a Rust app
• Update secret tags and content types
• List secret properties across multiple pages

Build agents for Teams and Microsoft 365 with TypeScript and Node.js. Covers message routing, Express hosting, streaming responses that display text as it arrives, and connections to Copilot Studio through its client library and WebChat.

• Building an agent that responds to Teams messages
• Displaying Azure OpenAI responses as text arrives
• Starting conversations with Copilot Studio from an application

Add group chat and live notifications to TypeScript applications using Azure Web PubSub. Implement two-way messaging over persistent WebSocket connections, with examples for user groups, access tokens, permissions, and server-side event handling.

• Building group chat organized into rooms
• Sending live notifications to specific users
• Validating connections and managing send permissions

Build Python messaging workflows with Azure Service Bus. Covers sending and receiving messages, publishing to multiple subscribers, retrying failed work, preserving message order, scheduling delivery, and handling messages that cannot be processed.

• Sending work between Python services
• Publishing events to multiple subscribers
• Retrying failed messages and inspecting the dead-letter queue

Implement Azure Files operations in JavaScript or TypeScript. Manage SMB file shares, a shared file storage format, create directories, upload and download files, set metadata, and create snapshots of stored content.

• Creating shared storage and setting capacity limits
• Implementing file uploads and downloads
• Updating file metadata or selected byte ranges

Implement Microsoft Entra ID authentication for Azure SDK clients in Rust. Choose credentials for local development, Azure hosting, or CI/CD, including managed identities, which let Azure resources authenticate without storing a client secret in application code.

• Authenticate a local Rust app with Azure CLI
• Use managed identities for Azure-hosted Rust apps
• Configure service principal authentication for CI/CD

Add Azure translation features to JavaScript or TypeScript applications. The skill covers translating text into multiple languages, detecting its language, converting between writing systems, and translating individual or batches of documents while tracking batch progress.

• Translate text into several languages
• Detect the language of incoming text
• Convert text between writing systems