Today, when building solutions with Azure Logic Apps Standard, Azure Functions, REST APIs, API Management, SaaS applications, and other cloud services, JSON is everywhere.
And wherever JSON messages are exchanged between systems, we eventually need to define and maintain the contract behind those messages.
That normally means JSON Schema.
Visual Studio Code already provides an excellent experience for editing JSON. We can write JSON Schemas manually, use IntelliSense, validate JSON documents, and of course use GitHub Copilot to help us generate schemas. And inside Logic Apps Designer we can actually easily convert a JSON into a JSON Schema.
But there is still one experience I believe is missing for integration developers: A proper Visual JSON Schema Editor.
An editor that allows us to understand, create, and maintain JSON Schemas visually instead of spending all our time navigating raw JSON definitions and we can easily apply validations or restrictions in fields.
This is another capability that the DevScope Integration Toolkit brings directly into Visual Studio Code.
π One-Minute Brief
JSON is everywhere in modern Azure integration solutions, but creating and maintaining complex JSON Schemas directly as code can quickly become difficult. The Visual JSON Schema Editor available in the DevScope Integration Toolkit brings a visual tree-based experience to Visual Studio Code, allowing developers to create and edit JSON Schemas, see a live preview and sample instance, or generate a schema directly from an existing JSON message.
We Need a Visual JSON Schema Editor for Azure Logic Apps Standard and VS Code
When we talk about enterprise integration today, JSON is impossible to avoid.
It is used everywhere:
- REST APIs
- Azure Logic Apps
- Azure Functions
- Azure API Management
- SaaS applications
- Event-driven architectures
- Microservices
- Mobile and web applications
- Custom applications
- Partner integrations
And although JSON itself is simple and human-readable, defining a proper JSON Schema can become considerably more complex.
A JSON payload like this is easy to understand:
{
"orderNumber": "PO-10001",
"customer": {
"id": "C001",
"name": "Contoso"
},
"lines": [
{
"product": "P001",
"quantity": 10,
"price": 25.50
}
]
}
But the JSON Schema describing that message needs to define concepts such as:
- objects
- properties
- arrays
- data types
- required properties
- nested structures
- constraints
- references
- definitions
And once schemas start becoming larger, understanding the actual message structure from the source code alone becomes increasingly difficult.
That is exactly where a visual JSON Schema editor becomes useful.
Yes, we can edit JSON Schema as code
Of course we can. JSON Schema is JSON.
We can create a .json file in Visual Studio Code and define something like:
JSON
{
"type": "object",
"properties": {
"orderNumber": {
"type": "string"
},
"customer": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"name": {
"type": "string"
}
}
},
"lines": {
"type": "array",
"items": {
"type": "object",
"properties": {
"product": {
"type": "string"
},
"quantity": {
"type": "integer"
},
"price": {
"type": "number"
}
}
}
}
}
}
And for small schemas, there is absolutely nothing wrong with that.
In fact, experienced developers can create and maintain JSON Schemas manually without much difficulty. And today, with tools such as GitHub Copilot, generating an initial JSON Schema from a sample payload is considerably easier than it used to be.
But again: Being able to edit JSON Schema doesn’t necessarily mean we have the best experience for understanding and maintaining JSON Schema.
The problem becomes much more visible when we move from a simple demonstration to an actual enterprise message.
Complex JSON Schemas are difficult to understand as code
Take a JSON Schema with ten properties.
No problem.
Now imagine a schema representing a real enterprise business document with:
- hundreds of properties
- deeply nested objects
- multiple arrays
- optional and required properties
- reusable definitions
- references
- enums
- validation constraints
- different data types
- objects inside arrays
- arrays inside objects
Suddenly, navigating hundreds or thousands of lines of JSON isn’t quite as enjoyable.
When looking at a schema like that, what we normally want to understand is not:
Plain Text
properties β customer β properties β address β properties
We want to understand the message itself:
Order
βββ OrderNumber
βββ OrderDate
βββ Customer
β βββ Id
β βββ Name
β βββ Address
β βββ Street
β βββ City
β βββ Country
βββ Lines
βββ Line []
βββ Product
βββ Quantity
βββ Price
βββ Discount
That is the difference between reading the implementation of a schema and understanding the message represented by the schema.
And that difference becomes extremely important when maintaining large integration solutions.
Visual tools aren’t only for developers who don’t know JSON Schema. This is something I also mentioned when discussing the XSD Schema Editor for Visual Studio Code and Logic Apps.
There is sometimes a misconception that visual designers are intended for developers who don’t understand the underlying technology. I completely disagree.
I can edit JSON Schemas manually. Most experienced integration developers can. But if someone gives me a 1,500-line JSON Schema describing a complex ERP document, I would still prefer to have a visual representation available.
Why?
Because visual representations are excellent for understanding structure. Code is excellent for precision. The ideal development experience gives us both.
And that is precisely what we should expect from our integration development tools.
Bringing a Visual JSON Schema Editor to Visual Studio Code
This is where the DevScope Integration Toolkit comes into the picture.
One of the capabilities included in the toolkit is a Visual JSON Schema Editor that allows developers to build and edit JSON Schemas as a tree directly inside Visual Studio Code. It also provides a live preview and sample instance, and can generate a schema from an existing JSON message.
Instead of forcing developers to work exclusively with the raw JSON Schema representation, we can work with the schema structure visually while remaining inside the development environment we are already using to build our integration solutions.
Create and Edit JSON Schemas
The main objective of the Visual JSON Schema Editor is straightforward:
Make JSON Schema development easier and more visual.
With the editor, we can build and edit .json JSON Schema files using a tree representation.
Instead of mentally reconstructing the hierarchy from the JSON definition, we can immediately understand how the message is organized.
Conceptually, we can see:

For integration developers, this gives us something extremely valuable:
- a message-centric view of the schema.
Instead of focusing on brackets, properties, and JSON Schema syntax, we can focus on the actual contract being exchanged between systems.
Live Preview and Sample Instance
Another useful capability is the ability to work with a live preview and a sample instance while designing the schema.

This is particularly valuable when creating or reviewing schemas because there are always two things we need to understand:
- What does my schema define?
- What would an actual message following this schema look like?
Those two views complement each other.
- The schema describes the rules and structure.
- The sample instance shows the actual message that an application, API, Logic App, or integration process will receive.
This makes it easier to understand the impact of the schema while we are designing it.
Generate a JSON Schema from a JSON Message
And then there is probably one of the most common scenarios for integration developers.
Someone gives you this:
{
"customerId": 1001,
"name": "Sandro Pereira",
"active": true,
"addresses": [
{
"city": "Porto",
"country": "Portugal"
}
]
}
And asks: Can you create the schema for this message?
Of course we can manually create it. Of course we can use Logic App Workflow designer with a Parse JSON to generate the Schema. We can also ask an AI assistant to generate one.
But when this is part of our normal integration development workflow, having that capability directly available in our development tooling is extremely convenient.
The Visual JSON Schema Editor can generate a JSON Schema from a JSON message, giving us an initial schema that we can then review and refine visually.


This is especially useful when working with:
- REST API payloads
- Logic Apps HTTP triggers
- third-party SaaS messages
- application integration messages
- event payloads
- partner interfaces
In many real integration projects, we don’t start with a JSON Schema. We start with a sample message.
Being able to transform that sample into our initial schema is therefore an important productivity feature.
The goal isn’t to hide JSON Schema
This point is important. A visual JSON Schema editor should not try to hide JSON Schema from developers. Quite the opposite. Integration developers should understand the technologies behind the tools they use.
The same applies to XSD, XSLT, XPath, JSONPath, Liquid, and every other technology we use in integration solutions.
But good tooling should help us be more productive.
Sometimes the best way to understand something is code. Sometimes it is a visual representation. And often, the best development experience is having both available at the same time.
That is exactly the experience I want when working with complex JSON Schemas.
Download
The DevScope Integration Toolkit brings several Azure Integration Services and BizTalk-oriented development capabilities into Download
DevScope Integration Toolkit is one integration toolbox that brings many of the developers needs:
- Visual Data Mapper
- Visual XSD Editor
- Visual JSON Schema Editor
- Flat File Wizard
- Schema Validator
- Workflow Diff
- XPath Tester
- Logic Apps JSON Path Tester
- Schema to C#
all integrated into Visual Studio Code.
Hope you find this helpful! If you liked the content or found it useful and would like to support me in writing more, consider buying (or helping to buy) a Star Wars LEGO set for my son.