Skill: Scaffolding a Logic Apps Standard Project for Migration

Purpose: This document is a definitive reference for AI agents creating the initial scaffold project structure for a Logic Apps Standard migration. It contains the exact files, folder structure, VS Code configuration, and runtime settings taken from a verified working project. Following this document precisely will produce a valid, runnable Logic Apps Standard project on the first attempt.

The scaffold creates the Logic App project and workspace file only. Custom code (local .NET functions) is NOT created during scaffolding — it is added later by a separate task using the dotnet-local-functions-logic-apps skill.

Table of Contents

1. Overview
2. Scaffold Output Structure
3. Naming Conventions
4. Complete File Reference
5. Step-by-Step Creation Guide
6. File Manifest & Verification Checklist
7. Troubleshooting

1. Overview

What the Scaffold Creates

The scaffold produces a ready-to-run Logic Apps Standard workspace that:

• Opens correctly in VS Code as a multi-root workspace
• Is recognized by the Azure Logic Apps (Standard) VS Code extension
• Can run locally with Azure Functions Core Tools and Azurite
• Has all required configuration for workflow design, debugging, and deployment
• Has a placeholder for custom code functions (folder created later, not during scaffold)
• Contains empty workflow folders ready for workflow definitions to be added

What the Scaffold Does NOT Create

• Custom code / local .NET functions — created later by the local functions skill
• Workflow definitions — workflow.json files are added during the conversion stage
• Connections — connections.json is created when connectors are configured
• Build outputs — lib/custom/net8/ or lib/custom/net472/ DLLs are produced by building the Functions project

When to Use This Skill

• At the start of a migration conversion, before any workflows or custom code are generated
• When creating a new Logic Apps Standard project from scratch
• When the agent needs to set up the target project structure for BizTalk/TIBCO/TIBCO/etc. migrations

2. Scaffold Output Structure

2.1 Directory Tree

out/
└── {workspaceName}/
    ├── {workspaceName}.code-workspace          ← VS Code multi-root workspace file
    │
    ├── {logicAppName}/                          ← Logic Apps Standard project
    │   ├── host.json                            ← Functions host configuration
    │   ├── local.settings.json                  ← Runtime settings (CRITICAL)
    │   ├── .funcignore                          ← Deployment exclusions
    │   ├── .gitignore                           ← Git ignore rules
    │   │
    │   ├── .vscode/
    │   │   ├── extensions.json                  ← Recommended VS Code extensions
    │   │   ├── launch.json                      ← Debug configuration
    │   │   ├── settings.json                    ← Logic App project settings
    │   │   └── tasks.json                       ← Build & run tasks
    │   │
    │   └── workflow-designtime/                 ← Design-time configuration
    │       ├── host.json                        ← Enables function discovery in designer
    │       └── local.settings.json              ← Design-time runtime settings
    │
    └── (Functions/)                             ← NOT created during scaffold
                                                    Created later by local functions skill

2.2 Key Points

1. out/ is the output root — all scaffolded projects go under out/
2. {workspaceName} is the workspace root — contains the .code-workspace file and project folders
3. {logicAppName} is the Logic App project — fully scaffolded with all config files
4. Functions/ is NOT created — it's a provision for the custom code task, created later using the local functions skill
5. No workflow folders are created — workflow directories (e.g., my-workflow/workflow.json) are added during conversion
6. No connections.json — created when connectors are configured, not during scaffold
7. No Artifacts/ folder — create it later only when maps, schemas, rules, or HIDX files are actually required
8. No lib/custom/ folder — create it later when the local functions project is added and built

3. Naming Conventions

3.1 Input Parameters

The scaffold requires these naming inputs:

3.2 Naming Rules

• workspaceName: Use lowercase with hyphens. This becomes the folder name and the .code-workspace filename.
• logicAppName: Use lowercase with hyphens. This becomes the Logic App folder name and is referenced in the workspace file, launch.json, and local.settings.json.
• No spaces in either name — use hyphens (-) as separators.
• Keep names short — they appear in paths, debug labels, and VS Code UI.

3.3 Derived Values

4. Complete File Reference

Every file below must be created exactly as shown. Placeholders {workspaceName}, {logicAppName}, and {absoluteLogicAppPath} must be substituted with actual values.

4.1 Workspace File — {workspaceName}.code-workspace

{
    "folders": [
        {
            "name": "{logicAppName}",
            "path": "./{logicAppName}"
        }
    ],
    "settings": {}
}

IMPORTANT: The Logic App folder is listed first (and only, during scaffold). When the Functions project is added later, it will be appended as a second entry in the folders array. The Logic App must always remain first.

Note on settings: The settings block can optionally include terminal.integrated.env.windows with a PATH to the Logic Apps DotNetSDK for local development. During scaffold, leave it as {}.

4.2 host.json

{
    "version": "2.0",
    "logging": {
        "applicationInsights": {
            "samplingSettings": {
                "isEnabled": true,
                "excludedTypes": "Request"
            }
        }
    },
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle.Workflows",
        "version": "[1.*, 2.0.0)"
    }
}

Key details:

• "version": "2.0" — Azure Functions v2+ host
• extensionBundle — Uses the Workflows extension bundle (NOT the standard Functions bundle). This provides all the Logic Apps built-in connectors and operations.
• The bundle version range [1.*, 2.0.0) means any 1.x version but not 2.x

4.3 local.settings.json (CRITICAL)

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_INPROC_NET8_ENABLED": "1",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet",
        "APP_KIND": "workflowapp",
        "AzureWebJobsFeatureFlags": "EnableMultiLanguageWorker",
        "ProjectDirectoryPath": "{absoluteLogicAppPath}",
        "WORKFLOWS_SUBSCRIPTION_ID": ""
    }
}

⚠️ CRITICAL: All these settings must be present from the start. Missing any of them will cause runtime failures when workflows or custom code are added later.

4.4 .vscode/extensions.json

{
    "recommendations": ["ms-azuretools.vscode-azurelogicapps"]
}

4.5 .vscode/launch.json

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Run/Debug logic app with local function {logicAppName}",
            "type": "logicapp",
            "request": "launch",
            "funcRuntime": "coreclr",
            "customCodeRuntime": "coreclr",
            "isCodeless": true
        }
    ]
}

Key details:

• "type": "logicapp" — requires the Azure Logic Apps (Standard) VS Code extension
• "funcRuntime": "coreclr" — Logic Apps host runtime
• "customCodeRuntime": "coreclr" — .NET 8 custom code runtime (default for new projects). If the project will use .NET 4.7.2 custom code, change to "clr".
• "isCodeless": true — indicates this is a Logic Apps project (not a raw Azure Functions project)

4.6 .vscode/settings.json

{
    "azureLogicAppsStandard.projectLanguage": "JavaScript",
    "azureLogicAppsStandard.projectRuntime": "~4",
    "debug.internalConsoleOptions": "neverOpen",
    "azureFunctions.suppressProject": true
}

Key details:

• "azureLogicAppsStandard.projectLanguage": "JavaScript" — This is correct even though custom code uses C#. This setting refers to the Logic Apps workflow engine language, not the custom code language.
• "azureFunctions.suppressProject": true — Prevents the Azure Functions extension from treating this as a Functions project and interfering with the Logic Apps extension.

4.7 .vscode/tasks.json

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "generateDebugSymbols",
            "command": "${config:azureLogicAppsStandard.dotnetBinaryPath}",
            "args": ["${input:getDebugSymbolDll}"],
            "type": "process",
            "problemMatcher": "$msCompile"
        },
        {
            "type": "shell",
            "command": "${config:azureLogicAppsStandard.funcCoreToolsBinaryPath}",
            "args": ["host", "start"],
            "options": {
                "env": {
                    "PATH": "${config:azureLogicAppsStandard.autoRuntimeDependenciesPath}\\NodeJs;${config:azureLogicAppsStandard.autoRuntimeDependenciesPath}\\DotNetSDK;$env:PATH"
                }
            },
            "problemMatcher": "$func-watch",
            "isBackground": true,
            "label": "func: host start",
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ],
    "inputs": [
        {
            "id": "getDebugSymbolDll",
            "type": "command",
            "command": "azureLogicAppsStandard.getDebugSymbolDll"
        }
    ]
}

Key details:

• "generateDebugSymbols" task — generates PDB files for debugging custom code
• "func: host start" task — starts the Azure Functions host, which runs the Logic App locally
• Both tasks reference azureLogicAppsStandard.* config paths provided by the Logic Apps extension
• The func: host start task sets up PATH to include NodeJs and DotNetSDK from the extension's auto-installed dependencies

4.8 workflow-designtime/host.json

{
    "version": "2.0",
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle.Workflows",
        "version": "[1.*, 2.0.0)"
    },
    "extensions": {
        "workflow": {
            "settings": {
                "Runtime.WorkflowOperationDiscoveryHostMode": "true"
            }
        }
    }
}

Purpose: This file enables the Logic Apps designer to discover available operations (built-in actions, connectors, and custom functions) at design time. Without this file:

• The visual designer won't show the "Call a local function" action
• Connector discovery may not work correctly in the designer

4.9 workflow-designtime/local.settings.json

{
    "IsEncrypted": false,
    "Values": {
        "APP_KIND": "workflowapp",
        "ProjectDirectoryPath": "{absoluteLogicAppPath}",
        "FUNCTIONS_WORKER_RUNTIME": "node",
        "AzureWebJobsSecretStorageType": "Files"
    }
}

Key details:

• "FUNCTIONS_WORKER_RUNTIME": "node" — This is intentionally "node" for design-time (NOT "dotnet"). The design-time host uses Node.js for operation discovery.
• "AzureWebJobsSecretStorageType": "Files" — Stores secrets as local files during development
• "ProjectDirectoryPath" — Must match the same absolute path used in the runtime local.settings.json

4.10 .funcignore

.debug
.git*
.vscode
__azurite_db*__.json
__blobstorage__
__queuestorage__
global.json
local.settings.json
test
workflow-designtime/

Purpose: Specifies files/folders to exclude when deploying the Logic App to Azure. These are development-only artifacts.

4.11 .gitignore

# Azure logic apps artifacts
bin
obj
appsettings.json
local.settings.json
__blobstorage__
.debug
__queuestorage__
__azurite_db*__.json

# Added folders and file patterns
workflow-designtime/

*.code-workspace

Purpose: Standard git ignore for Logic Apps projects. Note that local.settings.json is excluded (contains local-only settings and potentially secrets) and workflow-designtime/ is excluded (generated/local-only).

4.12 Empty Directories

No empty directories need to be created during scaffold.

Do NOT scaffold Artifacts/, lib/custom/, or lib/builtinOperationSdks/ by default. Create them later only when actually required.

5. Step-by-Step Creation Guide

Step 1: Determine Names

Determine the workspaceName and logicAppName from the migration context:

• workspaceName: Typically derived from the source project name or the migration task name (e.g., contoso-order-processing)
• logicAppName: Typically the target Logic App name (e.g., contoso-logicapp or order-processing-logicapp)

Step 2: Compute the Absolute Path

Compute {absoluteLogicAppPath} — the full absolute path to the Logic App folder:

{outputRoot}\{workspaceName}\{logicAppName}

Example: C:\projects\out\contoso-migration\contoso-logicapp

This path is used in local.settings.json and workflow-designtime/local.settings.json.

Step 3: Create Workspace File

Create out/{workspaceName}/{workspaceName}.code-workspace (see §4.1)

Step 4: Create Logic App Config Files

Create these files in out/{workspaceName}/{logicAppName}/:

Step 5: Create .vscode/ Files

Create these files in out/{workspaceName}/{logicAppName}/.vscode/:

Step 6: Create workflow-designtime/ Files

Create these files in out/{workspaceName}/{logicAppName}/workflow-designtime/:

Step 7: Create Empty Directories

Do not create any empty directories during scaffold.

Step 8: Verify

Verify the scaffold by checking:

• All 10 files exist with correct content
• No extra empty directories were scaffolded
• local.settings.json has the correct ProjectDirectoryPath
• workflow-designtime/local.settings.json has the correct ProjectDirectoryPath
• Workspace file references the {logicAppName} folder correctly

6. File Manifest & Verification Checklist

Complete File List (10 files)

Verification Checklist

• Workspace file exists at out/{workspaceName}/{workspaceName}.code-workspace
• Workspace file folders array contains the Logic App folder with correct name and path
• host.json has extensionBundle with Microsoft.Azure.Functions.ExtensionBundle.Workflows
• local.settings.json has ALL 7 required settings:
  • AzureWebJobsStorage
  • FUNCTIONS_INPROC_NET8_ENABLED
  • FUNCTIONS_WORKER_RUNTIME = "dotnet"
  • APP_KIND = "workflowapp"
  • AzureWebJobsFeatureFlags = "EnableMultiLanguageWorker"
  • ProjectDirectoryPath (absolute path)
  • WORKFLOWS_SUBSCRIPTION_ID
• launch.json has "type": "logicapp" and "customCodeRuntime": "coreclr"
• settings.json has "azureFunctions.suppressProject": true
• workflow-designtime/host.json has Runtime.WorkflowOperationDiscoveryHostMode = "true"
• workflow-designtime/local.settings.json has FUNCTIONS_WORKER_RUNTIME = "node" (design-time!)
• No scaffold-only empty directories exist
• No Functions/ folder exists (created later by local functions task)
• No workflow folders exist (created during conversion)
• No connections.json exists (created when connectors are configured)
• No Artifacts/ folder exists unless a later task actually needs artifacts
• No lib/custom/ folder exists until the local functions task creates/builds it

7. Troubleshooting

Common Scaffold Issues

Post-Scaffold: Adding Workflows

After scaffolding, workflows are added by creating folders under the Logic App root:

{logicAppName}/
├── my-workflow/
│   └── workflow.json
├── another-workflow/
│   └── workflow.json

Each workflow is a subfolder containing a single workflow.json file. See the Logic Apps workflow schema for workflow.json structure.

Post-Scaffold: Adding Custom Code

When custom code is needed, use the dotnet-local-functions-logic-apps skill to:

1. Create the Functions/ project as a sibling folder
2. Add the Functions folder to the workspace file's folders array
3. Build the Functions project to populate lib/custom/

The workspace file will be updated from:

{
    "folders": [{ "name": "{logicAppName}", "path": "./{logicAppName}" }]
}

To:

{
    "folders": [
        { "name": "{logicAppName}", "path": "./{logicAppName}" },
        { "name": "Functions", "path": "./Functions" }
    ]
}

Post-Scaffold: Adding Connections

When connectors (e.g., Service Bus, SQL, HTTP) are used in workflows, a connections.json file is created at the Logic App root:

{logicAppName}/
├── connections.json      ← Created when connectors are configured
├── host.json
├── local.settings.json
└── ...

8. Quick Reference Card

┌──────────────────────────────────────────────────────────────────────┐
│     Logic Apps Standard — Scaffold Project Structure                 │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  OUTPUT:                                                             │
│    out/{workspaceName}/                                              │
│    ├── {workspaceName}.code-workspace                                │
│    └── {logicAppName}/                                               │
│        ├── host.json                                                 │
│        ├── local.settings.json         ← 7 required settings        │
│        ├── .funcignore                                               │
│        ├── .gitignore                                                │
│        ├── .vscode/                    ← 4 files                    │
│        └── workflow-designtime/        ← 2 files                    │
│                                                                      │
│  TOTAL: 10 files                                                     │
│                                                                      │
│  PLACEHOLDERS TO SUBSTITUTE:                                         │
│    {workspaceName}      → workspace folder + filename                │
│    {logicAppName}       → Logic App folder name                      │
│    {absoluteLogicAppPath} → full path to logicapp folder             │
│                                                                      │
│  CRITICAL SETTINGS (local.settings.json):                            │
│    FUNCTIONS_WORKER_RUNTIME     = "dotnet"                           │
│    FUNCTIONS_INPROC_NET8_ENABLED = "1"                               │
│    APP_KIND                     = "workflowapp"                      │
│    AzureWebJobsFeatureFlags     = "EnableMultiLanguageWorker"        │
│    AzureWebJobsStorage          = "UseDevelopmentStorage=true"       │
│                                                                      │
│  NOT CREATED IN SCAFFOLD:                                            │
│    ✗ Functions/ project    (added later by custom code task)         │
│    ✗ workflow.json files   (added during conversion)                 │
│    ✗ connections.json      (added when connectors configured)        │
│                                                                      │
│  DESIGN-TIME:                                                        │
│    workflow-designtime/host.json must have:                           │
│      Runtime.WorkflowOperationDiscoveryHostMode = "true"             │
│    workflow-designtime/local.settings.json must have:                 │
│      FUNCTIONS_WORKER_RUNTIME = "node" (NOT "dotnet"!)               │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

Document Metadata