When working with Azure Logic Apps Standard, XML schemas are often treated as first-class resources. JSON schemas, however, typically play a different role. Most developers use them in the Parse JSON action or in an HTTP Request Trigger to validate payloads and dynamically expose tokens throughout the workflow.
Because of that, we don’t create a standalone JSON Schema resource every day. Still, dedicated JSON schemas matter in some situations, especially when using the Data Mapper feature in Logic Apps Standard.
In this post, I will explain when to create a JSON Schema resource and how to create one directly in Visual Studio Code.
📝 One-Minute Brief
JSON Schemas play a different role than XML Schemas in Azure Logic Apps Standard. Most developers create them directly inside Parse JSON actions or HTTP Request Triggers to validate payloads and expose dynamic content. However, Data Mapper requires reusable JSON Schema resources stored within the Logic App project. In this article, you’ll learn when to use dedicated JSON Schemas, how to create them in Visual Studio Code, and how GitHub Copilot can generate schemas faster while reducing manual effort and common mistakes.
Understanding JSON Schemas in Logic Apps Standard
Unlike XML schemas, JSON schemas are usually not stored as reusable artifacts in the Artifacts > Schemas folder within a Logic App project.
Most of the time, you will find them embedded directly in actions such as:
- Parse JSON
- HTTP Request Trigger
- Custom payload validation implementations
- and so on.
For example, when configuring a Parse JSON action, you can generate a schema directly from a sample payload:
{
"id": 1,
"name": "Sandro Pereira",
"country": "Portugal"
}
The Logic Apps designer can automatically generate a schema such as:
{
"type": "object",
"properties": {
"id": {
"type": "integer"
},
"name": {
"type": "string"
},
"country": {
"type": "string"
}
}
}
This works perfectly for most scenarios.
However, there is a limitation.
The built-in schema editor available in Logic Apps is quite basic. If you need advanced validation rules, complex nested structures, pattern matching, required property enforcement, or conditional validation logic, you must manually edit the JSON schema in that small screen panel or outside it, like in Notepad++.
When do you need a dedicated JSON Schema resource?
For most integration projects, the answer is simple: You probably don’t need one.
Most Logic App workflows can operate perfectly well with embedded schemas inside Parse JSON actions or HTTP triggers.
However, one important exception exists: Data Mapper.
Data Mapper
When using the Logic Apps Data Mapper, schemas become reusable project artifacts.
The Data Mapper requires source and destination schemas to perform transformations. While XML schemas have traditionally been used for this purpose, JSON schemas are equally supported and can be used as the foundation for mapping operations.
In this scenario, you must create a dedicated JSON Schema resource.
Creating a JSON Schema Resource in VS Code
Creating a JSON Schema inside a Logic Apps Standard project isn’t straightforward because VS Code doesn’t provide tooling to create JSON Schemas. Unless you use the Logic App Workflows designer to generate the JSON Schema based on a JSON Sample and manually copy it to a Schema file and store it in the Artifacts > Schemas folder.
You can also manually create the entire JSON Schemas without using the Logic App Workflows designer. For that, we just need to:
- Inside your Logic App Standard workspace, navigate to the Artifacts > Schemas folder.
- Create a new file with a
.jsonextension. For example:
Artifact
│
├──Schemas
│
├── CustomerSchema.json
- Next, add your schema definition. For example:
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "Customer",
"type": "object",
"properties": {
"customerId": {
"type": "integer"
},
"firstName": {
"type": "string"
},
"lastName": {
"type": "string"
},
"email": {
"type": "string",
"format": "email"
}
},
"required": [
"customerId",
"firstName",
"lastName"
]
}
- Save the file.
At this stage, the schema is ready for the Data Mapper to use or for you to reference elsewhere in your project.
Nothing prevents you from creating or maintaining it entirely in VS Code as a plain-text file. Technically, a JSON Schema is just a JSON file. Therefore, you could create one manually in VS Code or any other text editor. However, just because you can does not mean you should. Manually building JSON Schemas is both tedious and time-consuming.
For very simple schemas, this might be manageable. But as soon as complex types, repeating records, restrictions, and so on enter the picture, manual creation and maintenance quickly become error-prone.
Using GitHub Copilot to Generate a JSON Schema
One of the easiest ways to create a JSON schema in Visual Studio Code is by leveraging GitHub Copilot. Instead of manually writing every property, type definition, and validation rule, you can simply describe the structure you need and let Copilot generate the initial schema for you.
For example, create a new .json file and provide Copilot with a prompt such as:
Create a JSON Schema for a customer object with:
- CustomerId (integer)
- FirstName (string)
- LastName (string)
- Email (valid email format)
- BirthDate (date)
- IsActive (boolean)
Make CustomerId, FirstName, LastName, and Email required.
At the end Save it inside Artifacts > Schemas folder.
Copilot will generate something similar to:
This approach can significantly speed up schema creation, especially for large, complex payloads. However, as with any AI-generated artifact, you should always review the generated schema to ensure it correctly reflects your business requirements and validation rules.
I find GitHub Copilot especially useful for creating schemas intended for the Data Mapper, where manually defining dozens or even hundreds of fields can quickly become tedious. By generating the initial structure with Copilot and then refining it as needed, you can dramatically reduce development time while maintaining full control over the final schema.
Conclusion
Unlike XML schemas, JSON schemas are generally not a major asset in Logic Apps Standard projects. Most developers simply generate and use them directly inside Parse JSON actions or HTTP Request triggers.
Nevertheless, managing JSON schemas as standalone resources can be valuable in some situations. The most notable example is the Data Mapper, which requires dedicated source and target schemas to build transformations.
One challenge is that Visual Studio Code does not provide a visual JSON Schema designer like to one many developers are used to when working with XML schemas. Creating a JSON schema typically means manually writing the schema definition, including all properties, data types, required fields, validation rules, and nested structures. While this approach offers complete flexibility, it can be time-consuming, especially for large payloads, and is often prone to human error.
Fortunately, modern AI-powered tools such as GitHub Copilot can significantly simplify this process. By describing the expected JSON structure in natural language, Copilot can generate an initial schema in seconds, allowing developers to focus on refining validation rules and business requirements rather than manually typing hundreds of schema elements. This not only accelerates development but also helps reduce the likelihood of mistakes when building complex schemas.
Although you may not need JSON Schema resources every day, knowing how to create, maintain, and enhance them directly in VS Code is an important skill for any Azure Integration developer working with Logic Apps Standard. Combined with GitHub Copilot, the process becomes much faster and more productive, making JSON Schema creation far less tedious when dedicated schema resources are required.
I hope you find this helpful! If you liked the content or found it useful and want to help me write more, you can consider buying (or helping to buy) my son a Star Wars LEGO set.
