Strands documentation

## Sections
• [Overview](https://docs.strands.octue.com/strands-documentation-1/introduction-overview.md): Learn everything you need to know about managing and sharing JSON Schemas with Strands, your complete schema repository solution. Strands is your centralized JSON Schema management tool that empowers teams to easily create, publish, and share schemas. With built-in semantic versioning (SemVer) for tracking changes, global CDN distribution for speed, and robust collaboration features, Strands accelerates your development workflow. Maintain consistent data quality across applications through our modern schema registry and editor. Create an account Create a Strands account using your email to start building JSON schemas. Choose between a free account or a monthly subscription. As a non-profit venture, all funds support the JSON Schema community and the broader open-source ecosystem. Sign-up to Strands Create an account with your email Getting started If you're new to Strands, start here to learn the essentials of using JSON Schema and create your first Strand in our online editor. Get started with Strands Create your first strand JSON Schema fundamentals Learn the fundamentals of JSON Schema and master best practices to create schemas Need help? Browse our GitHub discussions to find solutions, share feedback, and ask questions. Our community and team are here to help you build the future of data together. GitHub discussions Ask questions, share feedback, and find solutions
• [Getting started](https://docs.strands.octue.com/new-section.md): Strands is an online application designed to simplify the creation, publishing, and management of JSON Schemas. It provides a centralized schema management platform that enables developers, data engineers, and technical teams to maintain control and consistency across their data structures. This Getting started section introduces you to Strands and helps you begin your journey with the platform. Here, you'll find: A detailed Get started guide that walks you through initial setup and basic operations A comprehensive Glossary that clarifies the technical vocabulary used throughout the documentation The following sections will guide you through Strands' core concepts and help you quickly become productive with the platform.
  • [Get started with Strands](https://docs.strands.octue.com/new-section/new-section-1.md): Prerequisites Before you begin, make sure you have: A modern web browser. Basic understanding of JSON Schema. Understanding of data validation concepts. A Strands account . A well-defined schema structure. Version number for your schema (using major.minor.patch format) Your user handle (which is displayed next to your username). Create a strand Creating a strand is a straightforward process: Click your profile icon and select Add new strand from the menu. Name your strand removing any trailing spaces to avoid errors. Optional: Add labels to your strand. Optional: Write a short description and a Readme. Click Create Strand to save your new Strand. Tip: The README of a JSON Schema helps users understand the broader context of a JSON schema. Use this file to document information that the technical schema definition alone doesn't convey, such as the schema's purpose, constraints, license, and sponsors. Add a schema Next, you'll need to enter a complete and valid JSON Schema. Select Add a version. Enter a complete and valid JSON Schema. You can: Manually write your schema in the text editor. Choose a template from our predefined examples. Click Set the version to store your changes. Note : If your schema references other schemas, make sure they are already published on Strands or accessible via a URL. Add a version to your Strand Strands utilizes Semantic Versioning (SemVer) to manage schema changes: Major: Incompatible changes. These changes will likely break existing integrations and require updates. Minor: Backward-compatible feature additions. It refers to new features that are added without affecting existing functionality. Patch: Backward-compatible bug fixes. Bug fixes are implemented without introducing new features or breaking existing functionality. To version your Strand: Assign a version number using the major.minor.patch format (e.g., 1.0.0 ). To finalize and publish your Strand, click Save version . 🎉 Success! Your Strand is now live on the CDN. What's next? Your schema is now accessible at the URL shown on the screen—use this URL to reference it in other schemas. You can now share your schema, integrate it into your applications, or create new versions as your data model evolves. Want to learn more? Dive into the following resources to continue growing your skills: JSON Schema best practices Key JSON Schema concepts JSON Schema design patterns
  • [Glossary](https://docs.strands.octue.com/new-section/core-concepts.md): Content Delivery Network (CDN) A distributed network of servers that delivers content, such as JSON Schemas, to users based on their geographic location, ensuring low latency and high availability. Dialect A specific variation of the JSON Schema language, defined by a unique identifier, which allows extensions and modifications to the standard specification. Draft A version of the JSON Schema specification that is under development or review before being officially released. JSON (JavaScript Object Notation) A lightweight data-interchange format that is easy for humans to read and write, and easy for machines to parse and generate. JSON Schema A vocabulary that allows you to annotate and validate JSON documents. It is used to define the structure, format, and validation rules for JSON data. JSON Schema Specification The official standard that defines the syntax, keywords, and behavior of JSON Schema for validation and structure description. Schema A blueprint that describes the structure and validation rules for a set of data. In the context of JSON, it defines the required properties, data types, and relationships within a JSON document. SemVer (Semantic Versioning) A versioning system that uses a three-part number (MAJOR.MINOR.PATCH) to indicate backwards-incompatible changes, new features, and bug fixes, respectively. Strand A set of JSON schemas published and managed on the Strands platform, often versioned and distributed via a global CDN. Vocabulary A collection of keywords in JSON Schema that are used to express specific validation constraints and structural rules.
• [JSON Schema fundamentals](https://docs.strands.octue.com/new-section2.md): JSON Schema is a powerful tool for validating, documenting, and controlling the structure of JSON data. Whether you're just starting with JSON Schema or looking to improve existing implementations, having a solid foundation of JSON Schema concepts will help streamline data management and improve interoperability across different applications. By treating your schemas as first-class citizens in your development process, you'll create more robust, maintainable, and effective systems. This section provides a comprehensive foundation in JSON Schema concepts and practical guidance to help you implement JSON Schema effectively across your organization. What You'll Learn In this section, you'll explore: Introduction to JSON Schema : Understand the purpose, benefits, and common use cases for JSON Schema in modern data ecosystems. Key JSON Schema concepts : Learn about the building blocks that drive effective schema design and implementation. Anatomy of a JSON Schema : Examine the structural components that make up a schema and how they work together. JSON Schema best practices : Master the essential practices for creating effective schemas that balance validation rigor with practical implementation requirements. Armed with these fundamentals, you'll be positioned to fully leverage Strands as your centralized schema repository. Strands doesn't just store your JSON Schemas—it transforms them into living, collaborative assets that drive consistency and take your organization's schema management to new heights of efficiency and reliability.
  • [Introduction](https://docs.strands.octue.com/new-section2/json-schema-basics.md): Learning objectives After reading this Introduction to JSON Schema document, you will be able to: Define JSON and explain its purpose as a data interchange format Describe the limitations of JSON that JSON Schema addresses Explain what JSON Schema is and its historical development Identify the key benefits of using JSON Schema for data validation Recognize common use cases for JSON Schema across different technical domains Understand how Strands enhances JSON Schema management in enterprise environments Articulate how JSON Schema improves data quality and system interoperability What is JSON? JavaScript Object Notation (JSON) is a lightweight, text-based data format that is easy to read and write. It was invented in 2001 by Douglas Crockford as a lightweight and human-readable data interchange format to address the limitations of existing methods like XML, which was verbose and required complex parsing. It uses a simple syntax of key-value pairs , similar to JavaScript objects, to represent structured data. A basic example of JSON data looks like this: JSON { "name": "Alice", "age": 30, "isStudent": false, "skills": ["JavaScript", "Python", "JSON"], "address": { "city": "New York", "zipCode": "10001" } } In this example: Keys are strings (like "name" and "age" ). Values can be strings ( "Alice" ), numbers ( 30 ), booleans ( false ), arrays ( ["JavaScipt", "Python", "JSON"] ), or nested objects ( {"city": "New York", "zipCode": "10001"} ). Because JSON's syntax is compact and easy to generate and consume, it became popular for exchanging data between web browsers and servers and to store and process data. However, JSON has some drawbacks, such as ambiguity, lack of structure, and vulnerability to errors. JSON Schema was created to standardize data exchange by providing a way to define the structure and validation rules for JSON data. What is JSON Schema? Consider the following valid JSON data that represents a book in a catalog: JSON { "bookId": 1, "bookName": "Meditations", "price": 12.50, "author": "Marcus Aurelius", "tags": ["philosophy"] } This JSON data, also called a JSON document or instance , doesn't say much about its constraints: Can the price be zero? Can bookId be a string? Can there be more than one tag? These are some of the questions that JSON Schema helps us answer. JSON Schema was first proposed in 2010 as an Internet-Draft by Kris Zyp to provide a standardized way to define the structure and validation rules for JSON documents. Influenced by XML Schema and other data validation standards, JSON Schema aimed to simplify data exchange between systems by ensuring that JSON data adhered to a predefined format. It has evolved through several drafts -versions of the JSON Schema specification (for example, draft 7, draft 2020-12, etc.)- each introducing new features and improvements to enhance flexibility and expressiveness. You can learn more about the evolution of JSON Schema in this blog article by Henry Andrews , a co-author of the JSON Schema drafts. Why is JSON Schema important? Some of the benefits of using JSON Schema when working with data are the following: Data validation: Ensures that JSON data follows expected structures. Standardization: Ensures consistency across different parts of your application or organization. Interoperability: Facilitates seamless data exchange across different systems. What are some common JSON Schema use cases? The framework JSON Schema provides to validate JSON data structures serves critical functions in different technical domains, ensuring that data meets specified requirements before processing. API contract validation : JSON Schemas serve as contracts for APIs, ensuring that data sent and received conforms to expected structures. This helps prevent errors and facilitates smoother integration between services. Configuration file validation : JSON Schema is used to validate configuration files for applications, ensuring that they include all necessary parameters and follow the expected format. Data validation in ETL pipelines : During Extract, Transform, Load (ETL) processes, JSON Schema can validate incoming data to ensure consistency and prevent data quality issues. Event-Driven Architecture : In event-driven systems, JSON Schema can validate event payloads to ensure that consumers receive correctly structured data. Database schemas for NoSQL databases : JSON Schema can define expected structures for collections in NoSQL databases like MongoDB, providing a layer of data integrity. There are many more ways JSON Schema is implemented. To learn more about how different industries use JSON Schema to ensure data consistency, reduce runtime errors, improve communication between teams, and establish clear expectations for data structures throughout their systems, read the JSON Schema blog . Why use Strands for managing your JSON schemas? Managing JSON Schemas at scale presents unique challenges that Strands addresses through its purpose-built platform. The following capabilities distinguish Strands as an enterprise-ready solution for schema management across complex organizations. Centralized schema management: Strands offers a unified platform to create, publish, and manage JSON Schemas, eliminating inconsistencies and simplifying version control. Version control with SemVer: Using semantic versioning, Strands makes it easy to track changes, identify breaking updates, and revert to previous schema versions if needed. Global distribution via CDN: Strands' global CDN ensures that schemas are accessible quickly and reliably across different environments. Enhanced collaboration: Strands facilitates seamless collaboration among teams, allowing users to share and reference schemas securely. Efficiency and automation: The upcoming no-code schema editor and version compatibility checker will streamline schema creation and maintenance for both technical and non-technical users. Armed with these capabilities, Strands transforms your schema management into an efficient, collaborative, and reliable process. When using Strands, you can expect reduced development friction, improved data quality, and more consistent implementation of data standards across your technology stack. Conclusion JSON Schema provides a robust framework for defining, validating, and documenting JSON data structures. By implementing JSON Schema in your data workflows, you gain significant advantages in data quality, system interoperability, and developer productivity. The ability to explicitly define data constraints eliminates ambiguity and reduces the potential for errors across systems. Strands enhances these benefits by offering a comprehensive platform for managing JSON Schemas throughout their lifecycle. With features like centralized management, semantic versioning, global distribution, and collaborative tools, Strands transforms schema management from a technical challenge into a strategic advantage. Whether you're developing APIs, managing configuration files, or ensuring data consistency across research projects, JSON Schema—especially when managed through Strands—provides the foundation needed for reliable data exchange in modern applications.
  • [Key JSON Schema concepts](https://docs.strands.octue.com/new-section2/key-json-schema-concepts.md): Learning objectives After reading this JSON Schema Core Concepts document, you will be able to: Explain the relationship between JSON Schema and JSON data. Interpret a basic JSON Schema document and understand how it validates properties, types, and constraints. Identify the building blocks of JSON Schema: vocabularies, dialects, and meta-schemas. List and describe the purpose of the eight main vocabularies in draft 2020-12. Understand how the meta-schema URL is used to specify which JSON Schema draft/dialect is being used Introduction JSON Schema is not a programming language but a declarative language that uses keywords -such as $id , properties , and $schema - to define the structure and constraints of JSON data. It serves as both a contract and a validation tool, ensuring data consistency, correctness, and compliance with predefined rules. A document that describes the semantics, constraints, and structure of JSON data is called a schema , which is itself written in JSON. The relationship between a JSON Schema and JSON data is similar to that between a blueprint and a building. Here's an example of a schema that describes the previous instance of a book product: JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/book.json", "title": "Book product schema", "description": "Schema for validating book catalog data including ID, name, price, author, and associated tags", "type": "object", "$comment": "This schema defines the structure for book entries in our catalog system", "properties": { "bookId": { "type": "integer", "description": "Unique catalog identifier for the book in the system", "examples": [12345, 9876], "minimum": 1 }, "bookName": { "type": "string", "description": "Full title of the book as it appears on the cover", "examples": ["The Great Gatsby", "To Kill a Mockingbird"] }, "price": { "type": "number", "description": "Retail price of the book in your local currency", "examples": [12.99, 24.50], "minimum": 0, "default": 9.99 }, "author": { "type": "string", "description": "Full name of the primary author of the book", "examples": ["F. Scott Fitzgerald", "Harper Lee"] }, "tags": { "type": "array", "description": "Categorization tags for easier book searching and filtering", "items": { "type": "string" }, "examples": [["fiction", "classic", "american"], ["mystery", "bestseller"]], "default": [] } }, "required": [ "bookId", "bookName", "price", "author" ] } As you can see by this example, the JSON Schema defines what properties should exist and their data types. This schema answers the previous questions about the book product JSON data: Can the price be zero? Yes, it can. Can the bookId be a string? No, it must be an integer. Can there be more than one tag? Yes, it is possible to add more than one tag to a book. The instance is the JSON data that is validated against the schema. When you validate an instance against a schema, you are checking if the instance adheres to the schema's rules. The building blocks of JSON Schema The building blocks of JSON Schema are vocabularies, dialects, and meta-schemas. Vocabularies are groups of keywords that are related to each other and a dialect is a collection of vocabularies. Every draft comes with a dialect and its structure is described by another JSON document called meta-schema -a schema that validates itself or another document. The most recent draft, draft 2020-12 , introduces several vocabularies, each serving distinct purposes: Core Purpose : Defines the fundamental elements for schema identification and referencing. Keywords that belong to this vocabulary are preceded by a dollar $ sign. Keywords : $id , $schema , $ref , $anchor , $defs , etc. Validation Purpose: Imposes structural and value constraints on JSON instances. Keywords: type , minimum , maximum , enum , required , etc. 3. Meta data Purpose: Provides annotations for documentation and user interfaces. Keywords: title , description , default , deprecated , examples , readOnly , writeOnly . 4. Applicator Purpose: Controls the application of schemas to specific parts of JSON instances. Keywords: properties , items , allOf , anyOf , oneOf , not , if , then , else , etc. 5. Format annotation Purpose: Provides semantic validation by describing the expected format of string data without enforcing it. Keywords: format (with values like email , uri, date-time ). 6. Format assertion Purpose: Extends format by making it assertive, which means format violations cause validation to fail if supported by the implementation. 7. Content Purpose: Useful for validating encoded or media-based content. Keywords: contentEncoding , contentMediaType , contentSchema . 8. Unevaluated Purpose: Allows validation rules to be applied to JSON objects without checking additional properties beyond what’s defined in the schema. This vocabulary is useful for enforcing constraints on objects without requiring a complete evaluation of all properties. Keywords: unevaluatedProperties , unevaluatedItems . All these vocabularies are included by default when using the meta-schema of dialect 2020-12: "$schema": "https://json-schema.org/draft/2020-12/schema" Conclusion JSON Schema provides a powerful framework for validating and documenting JSON data structures. In this document, you learned its core concepts, from basic definitions to the comprehensive vocabularies introduced in the 2020-12 draft. It has examined how schemas serve as blueprints for JSON data, defining properties, types, and constraints through declarative keywords. The various vocabularies—Core, Validation, Meta data, Applicator, Format annotation, Format assertion, Content, and Unevaluated—collectively enable precise control over data validation and documentation. By implementing JSON Schema, you can ensure data consistency, correctness, and compliance across systems, making it an essential tool for modern data management.
  • [Anatomy of a JSON Schema](https://docs.strands.octue.com/new-section2/anatomy-of-a-json-schema.md): Learning objectives After reading the Anatomy of a JSON Schema document, you will be able to: Identify the essential components that make up a JSON Schema document. Explain the purpose of structural keywords like $id and $schema in establishing schema identity and version. Recognize the importance of documentation keywords such as title and description Understand core validation keywords including type , required , properties , and additionalProperties Explain how to create reusable schema components using the $defs keyword. Understand the use of logical composition keywords ( allOf , anyOf , oneOf , not ) to create sophisticated validation rules. Identify the use of conditional validation if , then , and else keywords to create dynamic schema behavior. Articulate why the standard JSON Schema structure matters for identification, compatibility, documentation, and validation Top-level keywords Every JSON Schema document begins with a set of standard keywords that establish its identity, version, and basic validation rules. You can consult the JSON Schema official documentation to learn more about each keyword. Here's the skeleton of a typical JSON Schema: JSON { "$id": "https://example.com/my-schema", "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Product", "description": "A product in the catalog", "type": "object", "required": ["name"], "properties": { }, "additionalProperties": false } Let's break down these essential components: $id The $id keyword provides a unique identifier for your schema. This URI serves as the canonical URI for the schema and helps with referencing in more complex schemas. When other schemas need to reference this schema, they can use this identifier. $schema The $schema keyword specifies which version of the JSON Schema specification your schema is written against. This is crucial because different versions of JSON Schema may interpret keywords differently or offer different features. The example uses the 2020-12 draft, which is one of the more recent versions. title and description These keywords provide human-readable metadata about the schema: title: A short, descriptive title for the schema description: A more detailed explanation of what the schema represents While optional, they're highly recommended for documentation purposes as they make your schemas self-documenting. type The type keyword defines the data type that the JSON document must conform to. Common values include object , array , string , number , boolean , and null . required The required keyword contains an array of property names that must be present in the JSON document for it to be valid. In our example, an object must have a name property to be considered valid against this schema. properties The properties keyword defines the expected properties of the object and their respective schemas. This is where you specify the structure and validation rules for each property in your JSON data. additionalProperties Controls whether properties not specifically defined in the properties object are allowed. Setting it to false makes the schema strict, rejecting any undeclared properties. When set to true (the default), any additional properties are allowed. Other important keywords $defs This keyword provides a place to define reusable schema components that can be referenced throughout your schema: JSON "$defs": { "address": { "type": "object", "properties": { "street": { "type": "string" }, "city": { "type": "string" } } } } The address object can later be referenced in another or within the same schema, this is called reusability . See JSON Schema best practices to learn more about reusability. Logical Composition Keywords JSON Schema includes keywords that function as logical operators (AND, OR, NOT), allowing for sophisticated validation combinations. These keywords combine schemas in different ways: allOf (AND): Data must be valid against all of the subschemas. anyOf (OR): Data must be valid against at least one of the subschemas. oneOf (XOR): Data must be valid against exactly one of the subschemas. not (NOT): Data must not be valid against the specified schema. For a deeper understanding of these operators and how to implement complex validation rules, read Boolean JSON Schema composition from the official JSON Schema documentation. Conditional Validation Conditional validation allows you to apply different validation rules based on the properties or values in your data. This powerful feature enables dynamic schema behavior that adapts to the content being validated, similar to if-then-else statements in programming languages: if : Specifies a schema to test against. then : Schema to apply when the if schema validates successfully. else : Schema to apply when the if schema fails. This approach is particularly useful when validating documents where the presence or value of one field determines the validation rules for other fields. For example, you might require additional fields when a "type" field has a specific value or apply different format requirements based on a country code. You can learn more about these and other keywords to create conditional validation rules with the JSON Schema's documentation Conditional schema validation . Why this structure matters This standard structure is not just a convention but serves several important purposes: Identification : The $id uniquely identifies your schema in a global context, making it referenceable by other schemas. Version compatibility : The $schema ensures that validators know which rules to apply, preventing inconsistencies when the JSON Schema specification evolves. Documentation : The title and description provide human-readable information about the schema's purpose. Clear boundaries : Starting with type establishes clear expectations about what kind of data the schema validates. Explicit requirements : The required array makes it immediately clear which properties cannot be omitted. Flexible validation : Keywords like additionalProperties , logical composition keywords, and conditional validation provide powerful tools for expressing complex validation rules. Hierarchical structure : The properties object provides a natural container for nested validation rules, creating a hierarchical structure that mirrors the JSON data it validates. By following this standard structure, you can ensure your schemas are clear, compatible with validation tools, and easily understood by others. This consistency is key to JSON Schema's power as a data validation and documentation tool. Conclusion The structure of a JSON schema consists of several essential components that work together to define and validate JSON data. The top-level structure includes identifiers like $id and $schema that establish the schema's identity and version, metadata fields such as title and description that provide human-readable documentation and core validation keywords including type , required , properties , and additionalProperties . Each of these elements serves a specific purpose in creating a comprehensive blueprint for your JSON data, enabling you to enforce structure and constraints while maintaining clear documentation. Understanding these fundamental components gives you the foundation needed to create effective JSON Schemas for your data validation needs.
  • [JSON Schema best practices](https://docs.strands.octue.com/new-section2/json-schema-best-practices.md): Learning objectives After reading this guide, you will be able to: Identify common pitfalls when working with JSON schemas Understand the benefits of implementing JSON Schema best practices Apply reusability principles using the $ref keyword for common data structures Implement maintainability best practices through comments and proper documentation Create modular schemas by breaking down complex structures using $defs Organize schemas logically with appropriate metadata and structure Document schemas effectively using titles, descriptions, examples, and comments Establish consistent naming conventions that improve schema clarity Implement version control strategies for schema evolution Apply proper validation techniques to ensure data quality and consistency Introduction JavaScript Object Notation (JSON) has become the standard format for data exchange across applications and systems. JSON Schema is a specification that defines the structure and validation rules of JSON data. However, it is common to fall into one or several of the following pitfalls when working with JSON schemas: Defining redundant structures across multiple schemas Overcomplicating schemas with unnecessary nesting Lack of proper documentation and descriptions Poor versioning, leading to compatibility issues Inconsistent naming conventions Whether you're building APIs, managing data workflows, or ensuring data quality, following best practices for creating schemas is crucial for success. By implementing JSON Schema best practices, you will: Create more reliable data validation Reduce errors in data exchange Make schemas easier to maintain and update Improve documentation and team collaboration Enable automated testing and validation Enforce consistent data formats across your organization In this document, you will learn proven JSON Schema best practices, how they help you optimize your schemas, and how you can apply them to your schemas. Reusability ✅ Principle: Reusability refers to using data structures repetitively across your projects, schemas, services, or applications. 🔍 Why it matters: Making your schemas reusable avoids repetition, enhances modularity, and facilitates maintainability. 📝 How-to: Identify common data structures (e.g., addresses, phone numbers). Create standalone schema definitions for these structures. Reference them using the $ref keyword. 🛠 Example: Below is a JSON schema for an address : JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/address", "type": "object", "properties": { "street": { "type": "string" }, "city": { "type": "string" }, "country": { "type": "string" } } } This schema is referenced two times within a user schema using $ref . JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/user", "type": "object", "properties": { "name": { "type": "string" }, "shipping_address": { "$ref": "https://example.com/schemas/address" }, "billing_address": { "$ref": "https://example.com/schemas/address" } } } Maintainability ✅ Principle: Maintainability ensures schemas remain easy to update, extend, and manage over time. 🔍 Why it matters: Well-maintained schemas reduce technical debt, make updates easier, and help prevent breaking changes. 📝 How-to: Keep schemas simple and focused Use comments ( $comment ) to document schema changes. Implement consistent formatting and naming conventions . Document schema dependencies. Regularly review schemas for outdated properties and mark them with deprecated to guide users toward the latest structure. 🛠️ Example: This is an example schema demonstrating the use of $comment for documentation and deprecated for legacy fields. JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/product", "title": "Product Schema", "description": "Defines a product structure", "$comment": "Last updated: 2024-02-23 - Added categories", "type": "object", "properties": { "id": { "type": "string", "pattern": "^PRD-[0-9]{6}$" }, "categories": { "type": "array", "items": { "type": "string" } }, "sku": { "type": "string", "deprecated": true, "$comment": "Use 'productCode' instead." }, "productCode": { "type": "string" } } } Modularity ✅ Principle: Modularity involves breaking down complex schemas into smaller, manageable components. 🔍 Why it matters: Modular schemas are easier to understand, maintain, and reuse across different parts of your application. 📝 How-to: Break large schemas into logical components. Use $defs to store reusable components within the same schema. Create separate files for major components. Maintain clear dependencies between modules. 🛠️ Example: This example shows how to create modular JSON Schemas by defining the price component once in $defs and reusing it for different price fields ( subtotal , tax , and total ). JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/order", "type": "object", "$defs": { "price": { "type": "object", "properties": { "amount": { "type": "number" }, "currency": { "type": "string" } } } }, "properties": { "order_id": { "type": "string" }, "subtotal": { "$ref": "#/$defs/price" }, "tax": { "$ref": "#/$defs/price" }, "total": { "$ref": "#/$defs/price" } } } Organization and structure ✅ Principle: Good organization involves logical grouping of properties and appropriate use of data structures. 🔍 Why it matters: Well-organized schemas are easier to understand and maintain, leading to better data quality. 📝 How-to: Start your schemas with essential keywords- $schema , $id , title , description , and type - that define the schema itself. Avoid unnecessary nesting. Use arrays for repeated data. Group related properties logically. Keep the structure flat when possible. 🛠️ Example: This schema demonstrates good organization by including essential metadata keywords, minimizing unnecessary nesting, using arrays for repeated data, grouping related properties, and maintaining a flat structure for clarity and ease of maintenance. JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/customer", "title": "Customer Schema", "description": "Defines a customer and their associated orders", "type": "object", "properties": { "customerId": { "type": "string", "description": "Unique identifier for the customer" }, "name": { "type": "object", "description": "Full name of the customer", "properties": { "firstName": { "type": "string" }, "lastName": { "type": "string" } } }, "email": { "type": "string", "format": "email", "description": "Customer's email address" }, "phoneNumbers": { "type": "array", "description": "List of contact numbers", "items": { "type": "string" } }, "orders": { "type": "array", "description": "List of orders placed by the customer", "items": { "type": "object", "properties": { "orderId": { "type": "string" }, "orderDate": { "type": "string", "format": "date" }, "totalAmount": { "type": "number" } }, "required": ["orderId", "orderDate", "totalAmount"] } } }, "required": ["customerId", "name", "email"] } Documentation standards ✅ Principle: Documentation ensures that schemas are self-describing and easy to maintain. 🔍 Why it matters: Good documentation reduces onboarding time, prevents misunderstandings, and improves schema adoption and maintenance. 📝 How-to: Provide a meaningful title . Add a clear and concise description to schemas and properties. Use examples to show what valid data should look like. Document default values. Provide additional context or explanations with $comments . 🛠️ Example: This schema is well-documented because it includes comprehensive metadata (schema version, unique identifier, title, and description) alongside detailed property-level documentation with descriptions and examples for each field. The inclusion of developer notes via the $comment keyword and clear constraints with proper context ensures the schema serves as both a validation tool and effective technical documentation. JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/user", "title": "User Profile", "description": "Schema for a user profile containing basic personal details.", "type": "object", "properties": { "username": { "type": "string", "description": "A unique identifier for the user.", "examples": ["john_doe", "alice123"] }, "age": { "type": "integer", "description": "Age of the user in years.", "minimum": 0, "default": 18, "examples": [25, 30, 45] } }, "$comment": "Last updated: 2024-02-23 - Ensure all fields are documented." } In contrast, the schema below is poorly documented because it doesn't explain the purpose of the schema or provide any additional context. JSON { "type": "object", "properties": { "username": { "type": "string" }, "age": { "type": "integer" } } } Consistency and naming conventions ✅ Principle: Consistent naming makes schemas more predictable and easier to understand. 🔍 Why it matters: Consistency reduces cognitive load and makes schemas more intuitive to use. 📝 How-to: Choose a naming convention, for example camelCase or snake_case. Use clear and meaningful property names - status is vague but accountStatus gives more context. Avoid using abbreviations unless standard. 🛠️ Example: Contrast the names of the properties in the following schema, orderId , customerName , and shippingAddress , to the ones in the bad example below. JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/order.json", "title": "Order Schema", "description": "Schema defining an e-commerce order.", "type": "object", "properties": { "orderId": { "type": "string", "description": "Unique identifier for the order." }, "customerName": { "type": "string", "description": "Full name of the customer placing the order." }, "shippingAddress": { "type": "string", "description": "Shipping destination for the order." } } } Bad example: JSON { "id": { "type": "string" }, "name": { "type": "string" }, "addr": { "type": "string" } } Why the bad example is problematic: id is too generic—does it refer to an order ID, user ID, or something else? orderId clarifies this. name lacks specificity— customerName makes it clear who the name belongs to. addr is ambiguous— shippingAddress explicitly states what the field represents. Version control and schema evolution ✅ Principle: Version control helps manage schema changes and maintain compatibility. 🔍 Why it matters: Proper versioning prevents breaking changes and helps users migrate between versions. 📝 How-to: Use semantic versioning. Document breaking changes. Maintain backwards compatibility when possible. Include version in schema ID. 🛠️ Example: This schema demonstrates best practices for version control by using semantic versioning in the $id and documenting breaking changes with $comment . JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://example.com/schemas/user/v2.0.0", "title": "User Schema v2.0.0", "$comment": "Breaking changes from v1.0.0:'username' is now required, 'email' format is enforced, added 'role' property", "type": "object", "required": ["username", "email"], "properties": { "username": { "type": "string" }, "email": { "type": "string", "format": "email" }, "role": { "type": "string", "enum": ["user", "admin"] } } } Validation ✅ Principle: Strong validation ensures data quality and prevents errors. 🔍 Why it matters: Proper validation catches errors early and ensures data consistency. 📝 How-to: Use appropriate data types - boolean , array , null , object , number , integer , or string . Add constraints to data to ensure quality and consistency, for example minLength , multipleOf , required , etc. Validate formats for strings, for example email , uri , date-time , etc. Include required properties when needed. 🛠️ Example: This schema applies strong validation by enforcing data types, adding constraints for quality control, validating string formats, and ensuring required properties are properly defined. JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "required": ["id", "email", "age"], "properties": { "id": { "type": "string", "pattern": "^[A-Z]{2}-[0-9]{6}$" }, "email": { "type": "string", "format": "email" }, "age": { "type": "integer", "minimum": 0, "maximum": 120 }, "tags": { "type": "array", "uniqueItems": true, "minItems": 1, "maxItems": 5 } } } Conclusion By following the best practices outlined in this document, you can create JSON schemas that are both powerful and maintainable. Remember that well-designed schemas serve as crucial contracts between systems, enabling reliable data exchange and validation across your entire technology stack. The key principles we've covered—reusability, maintainability, modularity, organization, documentation, consistency, version control, and validation—work together to create schemas that are: Easy to understand and implement Adaptable to changing requirements Self-documenting and clear to new team members Reusable across multiple projects and systems Resistant to breaking changes As your applications and data structures evolve, regularly revisit your schemas to ensure they remain aligned with your current needs. Consider implementing automated testing for your schemas to catch inconsistencies early. Remember that investing time in thoughtful schema design yields significant benefits through reduced errors, improved interoperability, and more efficient development cycles.
• [Use cases](https://docs.strands.octue.com/use-cases.md): Welcome to the Use Cases section of the Strands documentation. This collection of resources highlights practical examples of how Strands' powerful schema management platform can solve real-world challenges across various industries. Each use case demonstrates how Strands enables organizations to streamline workflows, improve data consistency, and ensure data governance, all while enhancing efficiency and collaboration. Explore how Strands is used to: Enhance research efficiency by standardizing scientific data management and ensuring reproducibility . Future-proof enterprise data by mitigating data governance risks and simplifying compliance . Automate equipment data pipelines to boost operational efficiency in complex environments. Streamline API development with centralized schema management to improve collaboration and reduce errors. These case studies provide actionable insights into how adopting Strands can transform your organization's data management practices, making it easier to handle data at scale, improve accuracy, and drive innovation.
  • [Standardizing scientific data management: Enhancing research efficiency with Strands](https://docs.strands.octue.com/use-cases/standardizing-scientific-data-management-enhancing-research-efficiency-with-strands.md): Understanding scientific data management pain points As a researcher, you know that managing and sharing scientific data is crucial for collaboration and reproducibility. However, inconsistent formats, manual data cleaning, and data structure misalignment slow down research progress and introduce errors. Without a standardized approach, you spend more time fixing data issues than making discoveries. 🧩 Challenge 1: Inconsistent data formats across research collaborations When collaborating with colleagues across different institutions or departments, you often encounter inconsistent data formats and structures. Without standardized schemas, you waste hours cleaning, reformatting, and integrating data before analysis can even begin. This problem is particularly acute in fields like wind energy research , where complex power curve data requires precise formatting for meaningful analysis. 🧩 Challenge 2: Difficulty maintaining research reproducibility Scientific integrity depends on reproducibility, yet maintaining consistent data structures across experiments, researchers, and periods is challenging. Without properly documented and enforced data schemas, reproducing results becomes unnecessarily complicated, and valuable research findings may be questioned or underutilized. 🧩 Challenge 3: Time lost on data curation instead of scientific inquiry You became a researcher to make discoveries and advance knowledge, not to spend hours on data management. The 2022 State of Data Science by Anaconda Foundation reports that data scientists can spend around 38% of their time on data preparation tasks rather than analysis and interpretation. This imbalance represents a significant opportunity cost for your research progress. How Strands + JSON Schema transforms scientific data management JSON Schema it's a powerful way to define the structure, constraints, and documentation for your data. It acts like a blueprint or template that ensures all your data follows a consistent format. This standardization is crucial for scientific workflows where precision and consistency directly impact research outcomes. Learn more about JSON Schema in our comprehensive introduction. Strands is an online repository that allows you to create, publish, and manage JSON Schemas designed specifically to address the unique challenges faced by scientific researchers like you. Our solution empowers your team to standardize data formats while facilitating seamless collaboration across research projects. 💡 Solution 1 - Centralized schema management What it does: Strands provides a centralized repository for all your JSON schemas, accessible to everyone on your team with appropriate permissions. What this means for you: You can finally establish and maintain consistent data formats across all your research projects. Instead of wasting time reformatting data between collaborations, you can focus on actual analysis and discovery. When working with complex data like wind turbine power curves, everyone uses the same standardized format, eliminating interpretation errors and inconsistencies. 💡 Solution 2 - Version control and change tracking What it does: Strands implements proper versioning using SemVer (Semantic Versioning), allowing you to track schema evolution, highlight breaking changes, and facilitate rollback to previous versions when needed. What this means for you: You can confidently evolve your data structures as your research advances while maintaining backward compatibility with existing datasets. This ensures research reproducibility even as methodologies evolve, providing a clear audit trail of data structure changes throughout your research process. 💡 Solution 3 - Collaborative schema management with fine-grained permissions What it does: Strands enables controlled collaboration with team-based permissions and secure sharing capabilities for your schemas. What this means for you: You can collaborate with colleagues across institutions while maintaining appropriate access controls for sensitive research data. Easily share standardized schemas with external collaborators without compromising data security or intellectual property, facilitating wider research collaboration without the typical data formatting headaches. Real-world applications: how standardized schemas improve research efficiency in the wind energy sector The wind energy industry offers a powerful example of how structured data schemas can revolutionize research efficiency. Before standardization, wind turbine power curves lacked a consistent format, requiring manual transcription into machine-readable formats—an error-prone and time-consuming process. At WindEurope , industry experts highlighted a simple yet crucial rule: "Always, always, ALWAYS start with data structure." Defining a schema upfront brings clarity to your research workflow, ensuring every dataset follows a standardized format. Recognizing this inefficiency, Octue developed a JSON schema for power curve data that guarantees consistency in both input and output data for wind research projects. The goal? Minimize errors, reduce time spent on manual data curation, and enhance collaboration. This approach aligns seamlessly with Strands' commitment to schema-first data management. For scientific researchers, this means: You can design your schema in Strands before collecting or analyzing data. The schema serves as documentation for your team and future collaborators. Your data collection tools can validate against the schema in real time. Analysis code can rely on a consistent data structure, reducing errors. By adopting a schema-first approach, you eliminate manual data cleaning, improve research reproducibility, and future-proof your datasets—just as the wind energy sector has done. The Strands difference What sets our solution apart from alternatives in the market: Time recovery: Researchers using standardized schemas report spending up to 60% less time on data cleaning and preparation, freeing you to focus on scientific discovery rather than data management. Enhanced research quality: With consistent data validation against published schemas, you'll experience fewer data-related errors and greater confidence in your research outcomes. Simplified onboarding: New team members can quickly understand your data structure through well-documented schemas, reducing the learning curve for new collaborators and accelerating research progress. Future-proof research: As your research evolves, Strands grows with you, allowing you to adapt your schemas while maintaining compatibility with existing data and workflows. Get started with Strands To standardize your research data, begin by registering for Strands and creating your first Strand . Our platform integrates smoothly with your current systems, offering instant advantages. Explore our website or reach out to us for a customized demo. What you can expect After implementing Strands, your research team will experience: ⏱️ A reduction in time spent on data formatting and cleaning within the first month. 🤝 Improved collaboration with both internal and external research partners, with seamless data exchange. 🔬 Significantly enhanced research reproducibility, leading to greater confidence in your findings and increased citation potential for your published work. Ready to standardize your research data with Strands? Eliminate data formatting delays and accelerate your research, schedule your personalized demo today.
  • [Mitigating data governance risks: Future-proofing enterprise data with Strands](https://docs.strands.octue.com/use-cases/mitigating-data-governance-risks-future-proofing-enterprise-data-with-strands.md): The pain points of data governance Large enterprises face increasing pressure to maintain data quality, ensure compliance, and facilitate collaboration across teams. Modern relational databases increasingly support JSON, but managing JSON-based schemas at scale becomes a major challenge without proper governance. A lack of standardization leads to fragmented data models, compliance risks, and inefficiencies in collaboration. 🧩 Challenge 1: Schema fragmentation across teams Without a centralized schema repository, teams develop and manage schemas independently, leading to inconsistencies, redundant work, and integration issues. See the example of the UK's Driver and Vehicle Licensing Agency (DVLA) . 🧩 Challenge 2: Lack of version control and compliance tracking Manual schema management makes it difficult to track changes, enforce data standards, and maintain audit trails for compliance purposes. 🧩 Challenge 3: Time-consuming and costly manual processes to maintain data compliance You and your team likely spend countless hours manually managing schemas, validating formats, and resolving inconsistencies—wasting valuable resources that could be better spent on strategic initiatives. Strands: Enforcing proactive data governance and compliance for long-term security Strands is a specialized platform for creating, publishing, and managing JSON Schemas that provides enterprise-grade controls for data governance. Our solution empowers your data management team to establish and enforce data standards while facilitating collaboration between technical and business teams. 💡 Solution 1: Centralized schema repository - Say goodbye to data silos What it does: Strands provides a central hub where all your organization's JSON schemas are stored, managed, and distributed. What this means for you: You eliminate schema inconsistencies across teams and projects, making data integration seamless and improving data quality organization-wide. Teams across your enterprise work with the same schema definitions, drastically reducing data validation errors. 💡 Solution 2: Version control and audit trails - Maintain control and compliance What it does: Strands implements semantic versioning for all schemas, allowing you to track changes, identify breaking updates, and maintain backward compatibility. What this means for you: You gain complete visibility into schema evolution with clear audit trails. Your teams can confidently update schemas knowing which changes are breaking and which are compliant with industry regulations, while having the ability to roll back to previous versions when needed. 💡 Solution 3: Schema composition and referencing - Build complex data models What it does: Strands allows teams to reference and reuse schema components across multiple schemas, promoting standardization and reducing duplication of work. What this means for you: You can build and maintain complex data models from reusable components, ensuring consistency across your organization while simplifying maintenance. When a core component changes, all schemas referencing it automatically inherit those changes. The Strands difference Increased efficiency: Replace hours of manual schema management with automated version tracking and distribution, freeing your team to focus on higher-value data governance initiatives. Cost savings: Eliminating redundant schema management efforts leads to significant cost reductions in enterprise data operations. Ease of use: With an intuitive interface and upcoming no-code schema editor, Strands makes schema governance accessible to both technical and non-technical users. Automated validation workflow: Prevent breaking changes across teams by automatically validating schemas against specifications, ensuring references are resolved correctly, and verifying examples within schemas. Real-world example: DVLA's schema management approach The UK's DVLA has implemented a similar schema management approach to what Strands offers. With over 1,600 schemas in their data dictionary, they've built internal tools to manage schemas at scale, validate changes, and generate code. Their vision aligns perfectly with Strands: "Make it easy for teams to use standard data models and naming conventions across their data, contracts, and code." What took the DVLA significant internal development resources to build is available immediately with Strands as a ready-to-use platform. Their success demonstrates the value of centralized schema management in government and enterprise settings. Get started with Strands The first step toward better data governance is to sign-up for Strands and create your first Strand . Our platform provides immediate benefits with seamless integration into your existing systems and workflows. Visit our website to learn more or contact us directly to schedule a personalized demonstration. What you can expect After implementing Strands, your organization will experience: ⏱️ Reduction in time spent managing schema changes and resolving schema-related issues within the first quarter. ✅ Significantly improved data quality metrics within 3-6 months as standardized schemas are adopted across teams. 🛡️ Enhanced compliance posture with complete auditability of schema changes and usage across your enterprise. 🚀 Streamlined development processes as teams work from the same standard data models across applications. Ready to optimize your data governance framework for future scalability? Create a free account and start your journey with Strands or send us a message and let us know your needs, we're here to help you.
  • [Automating equipment data pipelines: Enhancing operational efficiency with Strands](https://docs.strands.octue.com/use-cases/automating-equipment-data-pipelines-enhancing-operational-efficiency-with-strands.md): The struggle for a unified data format across diverse technical equipment As a systems engineer, you manage data from different technical equipment and face significant challenges with data standardization and management. Each system outputs data in a different format, forcing you to create custom transformations that break when equipment changes. These fragmented, manual processes waste engineering time and introduce errors that compromise operational reliability. Strands automates these data standardization processes, streamlining your equipment data pipelines and eliminating the constant struggle to maintain consistency across your technical ecosystem. 🧩 Challenge 1: Fragmented data across multiple systems You must manage data from numerous equipment types, each with its own format and structure, creating a fragmented data landscape that's difficult to unify. 🧩 Challenge 2: Time-consuming manual data transformation You spend countless hours cleaning, transforming, and normalizing data from different sources, taking valuable time away from your core engineering tasks. 🧩 Challenge 3: Limited tools for data standardization Without specialized tools, maintaining consistent data definitions across your systems requires extensive custom coding and complex technical workflows. Why Strands + JSON Schema is a game-changer for automating equipment data pipelines JSON Schema is a powerful way to standardize, validate, and govern data structures across your organization. Learn more about what JSON Schema is and why it's important to ensure data consistency in our Introduction to JSON Schema . Strands is a comprehensive JSON Schema management platform designed specifically to address the unique challenges you face as a systems engineer. Our solution empowers you to standardize data collection across your equipment while reducing manual transformation efforts. 💡 Solution 1: Centralized schema repository - single source of truth What it does: Provides a centralized hub to store, manage, and distribute all your JSON schemas across your organization. What this means for you: No more scattered data definitions across your various systems or teams. With Strands, you maintain a consistent data structure across all equipment, dramatically reducing fragmentation and improving data reliability. 💡 Solution 2: Schema versioning and distribution - controlled evolution What it does: Implements semantic versioning for your schemas and distributes them via a global CDN, ensuring consistent access across all environments. What this means for you: As your equipment configurations change or new data requirements emerge, you can evolve your schemas in a controlled manner without breaking existing integrations. Your teams always access the correct schema version, eliminating inconsistencies and errors. 💡 Solution 3: No-code schema editor - simplified schema creation (Coming soon) What it does: Provides an intuitive visual interface for creating and modifying JSON schemas without coding expertise. What this means for you: You can design and implement standardized data structures across your equipment without extensive technical knowledge, democratizing schema creation and allowing you to focus on engineering rather than data formatting. The Strands difference Increased efficiency: Strands reduces the time you spend on data transformation allowing you to focus on analysis and optimization rather than data cleaning. Ease of use: Our platform is designed for users with varying technical expertise, making schema management accessible to your entire team without requiring specialized JSON knowledge. Scalability and flexibility: As your equipment inventory grows, Strands scales with you, handling everything from a few schemas to thousands while maintaining performance and accessibility. Get started with Strands Automate your equipment data pipelines in minutes, not months. Sign-up for Strands and create your first schema within minutes. Watch your manual data transformation hours disappear as your equipment data is automated through consistent pipelines. What you can expect After implementing Strands, you will experience: ⏱️ Reduction in time spent on manual data cleaning and transformation within the first month. 💯 Improved data reliability with standardized validation across all your equipment within weeks. 🔄 Simplified collaboration between your teams working with the same standardized data definitions. Ready to automate your equipment data pipelines with Strands? Contact us directly to schedule a personalized demonstration. Start automating today!
  • [Streamlining API development: Centralized schema management with Strands](https://docs.strands.octue.com/use-cases/using-strands-for-api-schema-management.md): API management pain points Software development relies heavily on well-designed, consistent APIs that serve as critical contracts between systems. As an API architect, you know that maintaining these contracts across distributed teams and services creates serious bottlenecks. When schemas live in multiple repositories, version inconsistencies become inevitable, breaking changes slip through, and every update becomes a coordination nightmare. The resulting technical debt doesn't just slow development, it directly impacts business agility and customer experience. Even industry leaders like Postman —whose 2022 State of the API Report found that an impressive 72% of respondents chose JSON Schema as their preferred API specification—face these challenges. Despite their significant resources, Postman conducted "a comprehensive internal research project" to understand the "diverse set of JSON Schema definitions" across their microservices and is exploring "a new microservice that acts as a central JSON Schema catalog API" to "promote reusability and discoverability." 🧩 Challenge 1: Schema version synchronization Managing and synchronizing schema versions across multiple services becomes increasingly complex and time-consuming, leading to inconsistencies and potential errors. As Postman discovered in their internal research, the diversity of JSON Schema definitions across microservices creates significant management overhead. 🧩 Challenge 2: Manual schema update distribution Distributing schema updates manually across teams and services creates bottlenecks in the development process and slows down implementation. Postman's exploration of "a central JSON Schema catalog API" highlights the industry-wide need for more efficient distribution methods. 🧩 Challenge 3: API consistency and backward compatibility Ensuring API consistency and backward compatibility becomes difficult without centralized oversight, increasing the risk of breaking changes. With JSON Schema being "the backbone of the most popular API specification technologies", including OpenAPI, AsyncAPI, and RAML, maintaining schema integrity is more critical than ever. Strands: Streamlining API development through centralized schema management Strands is a centralized JSON Schema management platform designed specifically to address the unique challenges faced by developer architects like you. Our solution empowers your team to streamline API development while maintaining consistency across your entire ecosystem through version control, global CDN distribution, and fine-grained permissions. 💡 Solution 1: Team collaboration tools - enhanced development coordination What it does: Offers granular permissions, access controls, and collaboration features specifically designed for schema management. What this means for you: Simplify complex coordination of schema changes with multiple team members. Ensure the right people have the right access at the right time, creating the "reusability and discoverability" that Postman identified as critical needs in their schema management approach. 💡 Solution 2: Centralized schema management - streamline version control What it does: Provides a single source of truth for all your JSON Schema files with comprehensive version tracking. What this means for you: No more manual schema file management or complex version tracking. Your team can focus on development rather than administration, reducing the risk of inconsistencies across services. You'll achieve externally what Postman is working to build internally: making "JSON Schema the source of truth" for your data structures. 💡 Solution 3: Global CDN distribution - automatic schema delivery What it does: Automatically distributes your schemas through a global Content Delivery Network to all necessary endpoints, addressing the same distribution challenges that API industry leaders are working to solve. What this means for you: Eliminate the time-consuming distribution of schema updates across services. Changes are immediately available where needed, accelerating your development process. The Strands difference Community-focused. Strands is deeply rooted in the open-source ethos. We are a community-focused organization where all revenue is reinvested directly into the JSON Schema ecosystem. This ensures continuous improvement, transparency, and a collaborative environment where user feedback shapes our development. This commitment fosters a vibrant community of developers and schema users, ensuring Strands remains relevant and responsive to evolving needs. Specialized focus. Unlike general-purpose tools, Strands is built specifically for JSON Schema management. This specialization allows us to deliver a purpose-built solution that addresses the unique challenges of JSON Schema design, versioning, distribution, and collaboration with unparalleled efficiency. We don't just offer features; we offer deeply optimized solutions tailored to the JSON Schema workflow. Future-proof. We're not just solving today's problems; we're anticipating tomorrow's challenges. Our roadmap includes features designed to simplify and streamline your workflow. Imagine a no-code schema editor that empowers non-technical users to contribute, a schema version compatibility checker that eliminates the risk of breaking changes, and seamless TypeScript package publication that bridges the gap between schema and code. These upcoming features will reduce technical barriers and democratize schema management, ensuring Strands remains at the forefront of innovation. Complementary to existing tools . Strands works perfectly alongside popular API platforms like Postman. While Postman excels at API testing, documentation, and client generation, Strands focuses specifically on the schema management lifecycle—providing the centralized schema catalog that even Postman is working to build internally. Get started with Strands Sign-up for free and select the plan that suits your needs. We'll walk you through creating your first Strand with our simple step-by-step guide . What you can expect After implementing Strands, your organization will experience: ⏱️ Reduced development time on schema-related tasks. 🔄 Improved API consistency with centralized schema management within the first month. 🛡️ Decreased risk of breaking changes through automatic version assistance and tracking. 💡 A system that delivers externally what industry leaders like Postman are building internally: a "central JSON Schema catalog" that becomes your "single source of truth." Ready to streamline your API management with Strands? Contact us today to schedule a personalized demonstration.
• [Troubleshooting and FAQs](https://docs.strands.octue.com/guides.md): In this section, you will find targeted solutions and insights to help you navigate common challenges in schema management and reference validation. Explore how these resources help you: Fix schema reference validation : Resolve SSL certificate and external schema referencing issues when using the jsonschema Python library Understand Strands platform details : Get answers to frequently asked questions about schema management, platform capabilities, and integration strategies These resources provide you with critical support to maximize the reliability and efficiency of your schema management workflows, ensuring smooth integration and minimizing potential technical obstacles.
  • [Fix schema reference validation in Strands](https://docs.strands.octue.com/guides/publishing-and-distributing-schemas.md): This troubleshooting guide addresses issues encountered when using the jsonschema Python library to validate schemas that reference external schemas hosted on Strands. It focuses specifically on resolving SSL certificate validation errors that occur when using the $ref keyword to reference schemas across different locations. Depending on the Python version you're using, you may experience SSL certificate errors when fetching remote schemas over HTTPS. Symptom: Schema reference validation fails When validating a JSON Schema that references another schema hosted on Strands using the $ref keyword, you may encounter an SSL certificate validation error that prevents successful schema resolution. Example schema of a person object referencing another schema that represents an address object: JSON { "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "person", "type": "object", "description": "JSON Schema (Draft 2020-12) for validating person data. Defines properties for first name, last name, age, email, and address. Ensures data consistency and interoperability.", "properties": { "firstName": { "type": "string", "minLength": 2, "maxLength": 50, "description": "The person's first name." }, "lastName": { "type": "string", "minLength": 2, "maxLength": 50, "description": "The person's last name." }, "age": { "type": "integer", "minimum": 0, "description": "The person's age." }, "address": { "$ref": "https://jsonschema.registry.octue.com/octue/address-object/1.0.0.json" }, "email": { "type": "string", "format": "email", "description": "The person's email address." } }, "required": [ "firstName", "lastName", "address" ] } } The error message may look like this: Plain text ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:997) ... referencing.exceptions.Unresolvable: https://jsonschema.registry.octue.com/valeria-hhdez/a-address/1.0.0.json Cause: SSL certificate validation failure Python versions before 3.13 may not handle SSL certificate validation correctly when fetching external schemas over HTTPS. This happens due to outdated or missing certificate bundles, leading to a failure in verifying the SSL certificates of remote resources. Solution 1: Upgrade Python Upgrading to the latest Python version will improve SSL handling and automatically manage certificate verification correctly. We recommend upgrading Python using the uv Python package manager . Install uv : Plain text pip install uv 2. Activate your uv environment: Plain text uv venv --python=3.13 myenv source myenv/bin/activate 3. Install the latest Python version: Plain text uv python install 4. Run your Python validation script using the latest Python version which now handles external schema referencing. Alternatively, download the latest Python version from the official website . Solution 2: Manually configure SSL certificate verification If upgrading Python is not an option, manually configure SSL certificate verification using the certifi package: Install certifi and ssl libraries Plain text python3 -m pip install --upgrade certifi python3 -m pip install --upgrade ssl 2. To use certifi for SSL verification, add the following lines to your Python script: Plain text import ssl import certifi import jsonschema import urllib.request ssl_context = ssl.create_default_context(cafile=certifi.where()) https_handler = urllib.request.HTTPSHandler(context=ssl_context) opener = urllib.request.build_opener(https_handler) urllib.request.install_opener(opener) This ensures that Python uses the latest certificates for HTTPS requests, allowing the schema reference to be retrieved successfully. Expected outcome After applying any of the solutions provided above, the schema validation should proceed without SSL errors and the jsonschema library should print a message with the results of the validation test of your JSON schema instance against the referenced schema. For more information Python SSL certificate verification jsonschema Python library uv Python package manager project certifi Python library
  • [FAQs](https://docs.strands.octue.com/guides/schema-compatibility-and-breaking-changes.md): What is Strands? Strands is an online platform for creating, publishing, and managing JSON Schemas. It offers version control, global CDN distribution, schema referencing and sharing, and user/team management with fine-grained permissions. Who should use Strands? Strands is designed for developers, data researchers, data governance managers, systems engineers, and anyone who needs efficient schema management, versioning, and collaboration tools. What problems does Strands solve? Strands centralizes JSON Schema management, streamlines version control, improves collaboration, ensures data consistency, and accelerates development workflows. Read our Use cases to learn more about how Strands solves real-world problems across different industries. What are the core features of Strands? Strands core features include: Schema versioning using SemVer. Schema publishing and distribution via a Global CDN. Schema referencing and sharing. User and team management with fine-grained permissions. How does Strands handle schema versioning? Strands follows semantic versioning (SemVer) to track changes in schemas, ensuring compatibility and highlighting breaking changes when necessary. What upcoming features can we expect? Upcoming features include: No-code schema editor. Schema version compatibility checker. Typescript package publication (automatic conversion of strands to Typescript types). What formats does Strands support? Currently, Strands focuses on JSON Schema. The platform will soon support automatic conversion to TypeScript types, with the potential for additional format support in the future. How can I use Strands in my existing data workflows? Schemas stored in Strands can be referenced in your applications, validation processes, and data pipelines. What level of technical expertise is needed to adopt Strands? Strands is designed for users with varying levels of technical expertise: Technical users can leverage the full power of JSON Schema and programmatic access. With the upcoming no-code editor, less technical users will be able to create and modify schemas without writing JSON directly. The platform's intuitive interface makes it accessible to users with different skill levels. How can I ensure my team adopts Strands effectively? To ensure effective adoption: Start with a pilot project to demonstrate value. Provide team training on Strands' features and benefits. Integrate Strands into existing workflows. Establish be st practices for schema management. Leverage our documentation and support resources . How does Strands improve data management efficiency? Strands improves efficiency by: Reducing time spent on manual schema management Eliminating inconsistencies that lead to errors and rework Streamlining collaboration among team members Automating schema distribution and updates Simplifying complex data management tasks
• [Product updates](https://docs.strands.octue.com/product-updates-and-support.md): In this section, you will find the latest information about Strands' evolution. These resources provide transparency into our platform's development and help you understand upcoming features and improvements. Explore how these resources help you: Stay informed : Get detailed insights into recent product releases and feature enhancements Plan your workflow : Understand our strategic direction and upcoming capabilities Anticipate improvements : Preview features that will streamline your schema management processes These resources will keep you updated on Strands' development, ensuring you can make informed decisions about integrating and leveraging our platform in your data workflows. Contents Release Notes Product Roadmap What to expect Our product updates provide a clear view of Strands' ongoing commitment to simplifying JSON Schema management. By maintaining transparency about our development process, we aim to build a platform that continuously meets the evolving needs of technical teams managing complex data structures. Participate in the discussion and help shape the future of Strands!
  • [Strands 0.1.0](https://docs.strands.octue.com/product-updates-and-support/release-notes/12-12-24.md): 05-12-2024 Strands is launching its first public release, providing a centralized platform for creating, publishing, and managing JSON Schemas. This initial release addresses key challenges when managing data across teams. Features Global CDN schema distribution. Strands offers a global Content Delivery Network (CDN) for fast and consistent schema retrieval across different environments. This feature ensures quick access to schemas from anywhere in the world. Semantic versioning for schemas. Implement schema versioning using SemVer , allowing precise tracking of schema evolution and easy identification of breaking changes. User and team management. Introduce fine-grained permissions for schema creation, editing, and access. Facilitate collaboration across teams with controlled schema sharing and management. Known Issues Limited no-code editor. The no-code schema editor is currently in development and will be released in a future update. Users can still create and manage schemas through the existing interface. Deprecation Notice None at this time. All features are new and supported. Bug Fixes None in this initial release We're excited to launch Strands and look forward to supporting teams in streamlining their data workflows. If you have any feature requests, we will be happy if you post your suggestions on our GitHub discussion.We're excited to launch Strands and empower teams to transform their data management processes. We're committed to continuous improvement, and we invite you to share your ideas and feature requests on our GitHub discussions. Your feedback will help shape the future of Strands. What features would supercharge your data workflows? Help shape the future of Strands! We want to hear your suggestions
  • [Product roadmap](https://docs.strands.octue.com/product-updates-and-support/product-roadmap.md): Current release (0.1.0) The current version of Strands has the following features: Global CDN schema distribution. Semantic versioning for schemas User and team management Initial REST API support Basic CLI operations Upcoming Features No-code schema management Develop a visual, user-friendly schema editor. Support schema creation for non-technical skills. Provide intuitive interface for schema modification. Schema version compatibility cheker Implement a version compatibility checker that detects potential breaking changes between schemas. Provide migration guidance between schema versions. Typescript integration Automatic conversion of JSON Schemas to Typescript types. Community-driven development We're committed to evolving Strands based on user feedback. Our roadmap is flexible and will adapt to the needs of our users. We welcome your input through our GitHub discussions .
• [Support and feedback](https://docs.strands.octue.com/release-notes-1.md): Open-source collaboration As an open-source project, Strands thrives on community contributions. We welcome developers of all skill levels to join our mission: Source code : Check out our source code on GitHub to explore the codebase, submit pull requests, and help improve Strands for everyone. Issue tracker : Report bugs or request features through our GitHub issue tracker . Please check existing issues before creating a new one. Community support Our community and team are committed to helping you build the future of data together. No matter where you are in your journey with Strands, we're here to support your success. GitHub discussions : Browse our GitHub Discussions to find solutions, share feedback, and ask questions. This is often the fastest way to get community-sourced answers.