Unizo Schema Studio : Custom Fields for Your Unified API

Meet Schema Studio—extend Unizo’s unified schema with Custom Unified Fields and map them to each tool’s objects and fields. Keep one consistent Unified API even as providers vary. Real time delivery, zero data retention.

 

Business value at a glance

• Accelerate time to market: add and map fields in minutes. No backend releases or schema forks.

• Single, stable API surface: per-connector mapping shields your product from provider changes.

• Lower total cost of ownership: less custom code and fewer support escalations.

• Compliance and security by design: real-time delivery with zero data retention at Unizo.

• Future-proof integrations: update mappings, not product logic, as tools evolve.

• Controlled change management: drafts, diffs, approvals, and versioning (roadmap).

 

Why Unified API + Custom Unified Fields Matter

Unified APIs already deliver big wins: one schema across tools, faster integrations, stable endpoints, consistent authentication, and lower maintenance. The trade-off has been a fixed set of fields per category and object—the least-common-denominator problem.

Schema Studio removes that ceiling. You keep all the strengths of Unizo’s unified schema and add Custom Unified Fields for the extra data your product needs. Fields are mapped per connector, stay normalized, and are delivered in real time with zero data retained by Unizo.

 

What’s New in Schema Studio

• Custom Unified Fields: add fields on top of the category → object model → custom field(for example, Ticketing → Ticket → cvss_score).

• Per-connector mapping: bind each field to provider-specific objects and fields (for example, Jira Issue, ServiceNow Incident).

• Validate and test: preview with sample payloads or live webhook deliveries before publishing.

• Governance (roadmap): drafts, diffs, approvals, and staged rollouts.

 

Key Capabilities for schema mapping and normalization

• Elastic on top of consistent: add Custom Unified Fields per category → object without forking the unified schema.

• Per-connector mapping: JSON path selection, lookups and enums, simple transforms, and defaults to normalize source values.

• Validate and test: preview with sample payloads, then send live webhook tests to verify normalized output before publishing.

• Trust by design: real-time delivery with zero data retention at Unizo, plus signing and delivery logs for observability.

• Change management (roadmap): drafts, diffs, approvals, and staged rollouts to reduce risk.

 

How it works

1. Open Console → Schema Studio.

2. Pick a category and object (for example, Ticketing → Ticket).

3. Click New Custom Unified Field (name, type, description).

4. Map it to source fields per connector, and add lookups, transforms, or defaults as needed.

5. Test and publish. The field appears in your Unizo unified API payload.

 

Example: Security Priority field with mapping across Jira and ServiceNow

 

Goal

Add a normalized Severity to Ticketing → Ticket. Keep the consistency of Unizo’s base model while exposing the extra field your product needs.

 

Define the field

{
  "category": "ticketing",
  "object": "ticket",
  "name": "security_priority",
  "label": "security priority",
  "type": "string",
  "description": "Normalized security priority coming from CISO team"
}

 

 

Map Per Connector

 

Consume in your App

{
  "id": "tic_123",
  "title": "Login never fails on SSO",
  "security_priority": "High",
  "source_id": "JIRA-42"
}

Result: one field with one meaning across tools—no tool-specific branching.

 

Security, privacy, and zero data retention

Unizo delivers in real time and does not retain your customer data. Schema Studio keeps this posture. Mappings execute on the fly.

Where Schema Studio Fits (Mental Model)

• Connectors = provider capabilities (e.g., Jira, ServiceNow, GitHub)

• Connections = authorized instances your customers create

• Schema Studio = extend Unizo’s unified schema with Custom Unified Fields, maintain per-connector mappings as tools evolve

 

Get Started in ~5 Minutes

1. Open Console → Schema Studio

2. Create a Custom Unified Field on the object you care about

3. Map, test, and publish

4. Query your Unified API and see the field in your responses

 

FAQs

What is a Custom Unified Field in Unizo?
A field you add on top of Unizo’s unified schema, then map to provider objects and fields (e.g., Jira Issue, ServiceNow Incident) to keep data normalized across tools.

How does Schema Studio help with field mapping and normalization?
Define a field once, then map provider-specific fields with lookups, simple transforms, and defaults so your Unified API remains consistent.

Does Schema Studio change existing Unified API payloads?
Nothing changes until you publish. After publishing, the new field appears in unified responses while existing properties remain unchanged.

Is data stored by Unizo during mapping?
No. Events are delivered in real time, and Unizo retains no customer data.

Can I test mappings before publishing?
Yes. Validate with sample payloads and send live webhook tests to confirm normalized output.