DevScope Integration Toolkit: JSON Schema Editor for VS Code and Logic Apps

  • Sandro Pereira
  • Nov 18, 2026
  • 8 min read

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:

JSON Schema Editor

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.

live preview

This is particularly valuable when creating or reviewing schemas because there are always two things we need to understand:

  1. What does my schema define?
  2. 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.

generate a JSON Schema
generate a JSON Schema result

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. 

Thanks for Buying me a coffe
Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc. He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book β€œBizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.

Leave a Reply

Your email address will not be published. Required fields are marked *

The Ultimate Cloud
Management Platform for Azure

Supercharge your Azure Cost Saving

Learn More
Turbo360 Widget

Back to Top