| Cover image | Cover image (dark) | Cover image (dark) | Cover image (dark) | |||
|---|---|---|---|---|---|---|
| :play: Get Started | New to Kizen? Start here with guides, tutorials, and key concepts. | /spaces/Qd8ufpN7wkdnx7JtgoeZ/pages/PbYb0GukRhiS4qCHdRal | /files/HMWeRzl8SfMmkQxvgcKf | /files/Y368xQAz1kTHTspvPRLN | /files/Y368xQAz1kTHTspvPRLN | |
| :bulldozer: Build Integrations | Connect Kizen with your stack using webhooks and APIs. | /spaces/Qd8ufpN7wkdnx7JtgoeZ/pages/GMSt8SKGZgnlmlinriBF | /files/LxA0Qv69p3LocZVcYMrJ | /files/FePgcoxeHp4E4MXqizEX | ||
| :robot: Automate with AI | Orchestrate AI agents and Agentic Workflows with primitives. | /spaces/CreM2KCc3dXtXwkCH8rX/pages/trLwwmumlaofzMKwR3fr | /files/9P0vpzquahp9R5b0bHEd | /files/4HMymBtlPAzlOGMGHDBe | /files/4HMymBtlPAzlOGMGHDBe | /files/4HMymBtlPAzlOGMGHDBe |
space.vars.Kizen\_company\_name is a leading AI platform for the future of work, redefining how people and AI seamlessly move and improve as one. Founded on the principle that technology should make work more meaningful, space.vars.Kizen\_company\_name creates AI systems and assistants that learn, adapt, and improve over time, just like the people who use them.\
\
Today, space.vars.Kizen\_company\_name powers millions of mission-critical experiences for leading organizations in highly regulated industries like insurance, healthcare, and financial services. We help companies realize the AI opportunity by delivering production-ready AI assistants for their teams. It molds to your unique business setup and keeps your teams in charge and performing at their best. The result: up to 4–8× productivity and climbing across regulated fields.
This site includes basic concept topics, tutorials, and walkthroughs of space.vars.Kizen\_company\_name's platform, as well as more technical content such as API references and plugin documentation to help you get up and running quickly.
### What You Can Build with Kizen
space.vars.Kizen\_company\_name provides a flexible, event-driven architecture that lets you automate and extend your systems in powerful ways. Admins and Technical Builders commonly use space.vars.Kizen\_company\_name in different ways*.*
{% columns %}
{% column %}
#### **Admins**
* Configure API connections and credentials
* Manage data schemas, fields, and permissions
* Define workflow rules and operational logic
* Set up integrations with third-party systems
* Maintain business settings across industries
{% endcolumn %}
{% column %}
#### **Technical Builders**
* Connect external systems using APIs, webhooks, and plugins
* Orchestrate AI-driven and multi-system workflows
* Query, transform, and sync data programmatically
* Enrich platform data using third-party services
* Build domain-specific space.vars.automations for insurance, healthcare, and financial services
{% endcolumn %}
{% endcolumns %}
Everything in space.vars.Kizen\_company\_name is connected. One update can power dozens of insights and space.vars.automations across your business. If your goal is to manage, integrate, automate, or customize your enterprise workflows, you've come to the right place!
### Jump Right In
:head-side-gear: | Kizen Basics | Learn the core concepts behind how data, space.vars.entities, space.vars.activities, and space.vars.automations are structured in space.vars.Kizen_company_name with a fun walkthrough tutorial. | /pages/PbYb0GukRhiS4qCHdRal | ||
:leaf: | Concepts | Dive deep to understand the core building blocks behind Kizen's Agentic OS capabilities, so you can extend them. | /pages/aOjs4gC5WzIpifbjuGsn | ||
:plug: | Integrations & Plugins | Integrate your data, automate cross-system space.vars.automations, and add customer UI actions with space.vars.Kizen_company_name's integration tools. | /pages/GMSt8SKGZgnlmlinriBF |
space.vars.automations, and plugins
* **Technical Teams** orchestrating AI-driven workflows
* **Solution Architects** connecting enterprise systems
* **Platform Engineers** extending space.vars.Kizen\_company\_name across complex environments
* **Implementers** creating specialized industry flows (insurance, healthcare, and financial services)
If you work with APIs, space.vars.automations, system integrations or just need to understand how space.vars.Kizen\_company\_name works, this is your home base!
### Industry-Specific Use Cases
space.vars.Kizen\_company\_name supports a wide range of industry workflows. The use cases below show how insurance, healthcare, and financial services teams leverage space.vars.automations, integrations, and data orchestration to power their core processes.
{% tabs %}
{% tab title="Insurance" %}
### Insurance
#### **Admins**
* Configure agent permissions, compliance rules, and required enrollment fields
* Set up business settings for quoting, enrollment, and multi-carrier workflows
#### **Technical Builders (Developers, Architects, Implementers)**
* Build integrations with quoting and enrollment platforms (SunFire, Connecture, carrier APIs)
* Automate end-to-end insurance workflows such as plan comparisons, eligibility checks, and renewals
* Sync agent, member, and policy data across external systems
* Create custom plugins for lead routing, quoting tools, or compliance logic
{% endtab %}
{% tab title="Healthcare" %}
### **Healthcare**
#### **Admins**
* Manage provider permissions, data-sharing rules, user roles, and HIPAA-aligned configurations
* Set up scheduling preferences, intake settings, and clinic-level workflows
#### **Technical Builders (Developers, Architects, Implementers)**
* Integrate EHR/EMR systems (Epic, Cerner, Athena) with operational workflows
* Automate patient journeys such as referrals, prior auth requests, and clinical follow-ups
* Sync clinical and operational data from HL7/FHIR endpoints
* Build plugins for data validation, scheduling logic, or care management tools
{% endtab %}
{% tab title="Financial Services" %}
### **Financial Services**
#### **Admins**
* Configure compliance rules, approval flows, and access permissions
* Set up business logic for onboarding, transactions, underwriting, or servicing
#### **Technical Builders (Developers, Architects, Implementers)**
* Connect CRMs, loan origination systems, underwriting engines, and servicing platforms
* Automate workflows like KYC/AML checks, risk evaluation, onboarding, and transaction processing
* Sync customer and financial data across internal and external systems
* Customize space.vars.Kizen\_company\_name with plugins for verification, payment flows, document extraction, or reporting
{% endtab %}
{% endtabs %}
space.vars.Kizen\_company\_name maintains a portion of its more technical documentation in open-source GitHub repositories. This allows our technical builders such as developers, partners, and the broader space.vars.Kizen\_company\_name community to improve accuracy, expand examples, and keep documentation aligned with real-world usage.
Not all documentation is open-sourced; some internal or business-specific content remains private to ensure security, compliance, and platform integrity. However, when a page on our documentation site includes the **Edit on GitHub** link, that means you can contribute directly.
This guide explains how to submit updates, corrections, or additions to any open-source space.vars.Kizen\_company\_name documentation.
***
### What You Can Contribute
You can contribute to any documentation that:
* Includes an **Edit on GitHub** link
* Lives in a public space.vars.Kizen\_company\_name GitHub repo
* Is not part of restricted or internal space.vars.Kizen\_company\_name content
Typical contributions include:
* Fixing typos or formatting issues
* Adding missing details or clarifying confusing sections
* Contributing new examples or best practices
* Updating code samples to reflect current API behavior
* Improving accuracy for plugin or integration guides
space.vars.Kizen\_company\_name docs.
{% stepper %}
{% step %}
#### Open the documentation page
* Go to the developer.kizen.com page you want to improve.
* Click **Edit on GitHub**.
{% endstep %}
{% step %}
#### Fork the repository
* On GitHub, select **Fork**.
{% hint style="info" %}
**Note:** Forking the repository creates your own copy to edit.
{% endhint %}
{% endstep %}
{% step %}
#### Create a new branch
In your fork, type the following into your CLI:
```bash
git checkout -b update-docs-[short-description]
```
{% hint style="success" %}
**Example:** update-docs-fix-webhook-example
{% endhint %}
{% endstep %}
{% step %}
#### Make your changes
* Edit the Markdown file GitHub opened. Make sure to keep the change focused and match existing formatting, tone, and style.
{% endstep %}
{% step %}
#### Commit your update
Use a clear commit message, for example:
```bash
git commit -m "Clarified webhook payload example and fixed query parameters"
```
{% endstep %}
{% step %}
#### Push your branch
```bash
git push origin update-docs-[short-description]
```
{% endstep %}
{% step %}
#### Open a Pull Request
In GitHub, select **Compare & Pull Request**.
Add a short summary to explain why the change is needed, and provide a link to the doc page.
{% hint style="info" %}
**Note:** If you changed formatting on the page, please include before/after screenshots.
{% endhint %}
{% endstep %}
{% endstepper %}
Once submitted, the PR enters space.vars.Kizen\_company\_name’s review workflow.
space.vars.Kizen\_company\_name’s documentation maintainers review your changes
* They may request revisions or ask follow-up questions
* Once approved, your contributions will be merged
* Within minutes, your update will be published.
You will receive a GitHub notification when the PR is merged.
{% hint style="warning" %}
**Caution:** Not all documentation is open sourced. Pages without an Edit on GitHub link are maintained internally and cannot be edited through GitHub contributions. If you want to propose updates to non-open-source docs, you can submit feedback using the suggestions link on the page or report it through space.vars.Kizen\_company\_name's support.
{% endhint %}
### 🙌 Thank You for Contributing
Community contributions help keep our documentation accurate, helpful, and aligned with real developer needs.
# Where To Get Help
Troubleshoot Kizen issues fast. Access developer docs, API references, support resources, and contact the Kizen support team for expert help.
The following resources are available if you encounter issues while building with space.vars.Kizen\_company\_name.
### Helpful Resources
* [ ] [Kizen Support Portal](https://support.kizen.com/support/home): Help articles and troubleshooting for using the space.vars.Kizen\_company\_name platform.
* [ ] [Kizen Interactive API Reference](https://app.go.kizen.com/api/docs/public/swagger): An interactive API reference that allows developers to explore space.vars.Kizen\_company\_name endpoints, view request/response schemas, and test API calls directly in the browser.
* [ ] GitBook Assistant: An AI-powered chat available on every page of space.vars.Kizen\_company\_name's TechDocs that allows users to explore documentation, get answers to questions, and navigate to relevant content.
***
## Contact Kizen Support
If you still need help, contact us by [submitting a ticket](https://support.kizen.com/support/tickets/new) or reaching out via email at [**support@kizen.com**](mailto:support@kizen.com).
When reaching out, include the following information (if able) to help us troubleshoot effectively and quickly:
* **Clear description of the issue:** What is happening and what you expected to happen instead.
* **Steps to reproduce the problem:** The actions taken before the issue occurred.
* **Relevant Object or Record IDs:** IDs for space.vars.objects, space.vars.entities, space.vars.activities, or space.vars.workflows involved in the issue (if applicable).
* **API request details:** Endpoint used, request body, headers, and any error responses (if applicable).
* **Screenshots:** Visual evidence of the problem when possible.
Providing these details allows us to reproduce and diagnose the issue more efficiently.
# What is Kizen?
Learn what Kizen is, how it structures data, Agentic Workflows, and Activities, and how these components work together across the platform.
## Overview
space.vars.Kizen\_company\_name is an Agentic OS built for you to take control of your data and coordinate all the moving parts of your business. It's like a conductor for your entire tech stack that ensures every system knows its role and performs in harmony without chaos or conflict.
Most space.vars.Kizen\_company\_name users start by creating space.vars.objects, logging space.vars.activities, and setting up simple space.vars.workflows. Over time, your teams can add space.vars.automations, custom reporting, and integrations to support larger and more complex processes.
The goal is the same for every business: make work easier, faster, and more consistent.
space.vars.Kizen\_company\_name is an Orchestration System built for the Agentic Era—a new phase of technology where AI systems don't just provide answers—they take action to help enterprises better understand their business, automate actions with AI-powered space.vars.workflows, and safely build custom applications at scale.
space.vars.Kizen\_company\_name speeds up engineering and drives real business value with ready-to-use industry solutions and a platform that lets teams turn prototypes into production quickly and confidently. With built-in compliance standards like SOC 2, ISO 27001, and HIPAA, space.vars.Kizen\_company\_name gives you the speed, clarity, and control you need to deploy space.vars.automation and AI safely at scale.
### **What You Can Do In Kizen**
space.vars.Kizen\_company\_name brings your data and operations into one unified place. Common tasks include:
* Organizing information using space.vars.objects and space.vars.entities
* Tracking interactions through space.vars.activities and space.vars.timelines
* Creating space.vars.workflows to guide your process from step to step
* Automating tasks like sending messages, assigning work, or updating space.vars.entities
* Building dashboards to view trends and performance on charts
* Customizing the platform with integrations, plugins, and APIs
Each feature builds on the other. By the end of the space.vars.Kizen\_company\_name Basics, you’ll have created your own space.vars.objects, space.vars.entities, space.vars.workflows, and space.vars.automations using an example business.
### **Why Kizen Matters**
Every business runs on processes. The more systems, steps, and people involved, the harder it is to keep everything consistent, accurate, and traceable.
space.vars.Kizen\_company\_name solves this by giving teams and enterprises:
* One system for data and history
* Guided workflows that reduce confusion
* space.vars.automations that handle repetitive tasks
* Integrations that connect your other tools
* Reporting highlights performance and issues.
Instead of switching between apps, or losing work in email threads, space.vars.Kizen\_company\_name creates a unified single source of truth for your operations.
***
## **Who This Is For**
space.vars.Kizen\_company\_name supports multiple user roles. However, for this purposes of this documentation we are focused only on the following:
{% columns %}
{% column %}
#### **Admins**
Admins configure the system, create data structures, customize fields, manage permissions, and set up space.vars.workflows or space.vars.automations.
{% endcolumn %}
{% column %}
#### **Technical Builders**
Technical builders like developers, implementors, and solution architects can use space.vars.Kizen\_company\_name’s APIs, webhooks, and integration tools to connect external systems, move data between platforms, and automate complex processes.
{% endcolumn %}
{% endcolumns %}
If you’re a technical builder and you already understand the space.vars.Kizen\_company\_name Basics, you can skip ahead in the tutorial at any time to learn more about the more technical concepts such as:
* [Building With APIs](/docs/developers/building-with-apis)
* [Generating API Credentials](/docs/developers/building-with-apis/generating-api-credentials)
* [Creating Your First API Call](/docs/developers/building-with-apis/creating-your-first-api-call)
***
## **What’s Next?**
Next, we’ll explore [How Kizen is Structured](/docs/kizen-basics/how-is-kizen-structured), including:
* space.vars.objects and space.vars.entities
* space.vars.activities & space.vars.timelines
* space.vars.automations
* space.vars.dashboard views & Charts
* Settings & App Marketplace
Understanding these components early will make building your first space.vars.workflows and space.vars.automations much easier.
Developers that already understand the basics may skip ahead to the API topics in the dropdown below. Otherwise, continue to [How is Kizen Structured](/docs/kizen-basics/how-is-kizen-structured).
space.vars.Kizen\_company\_name organizes and connects your data is the foundation for everything you build in the platform. For Admins and Technical builders, these building blocks make it easier to understand the platform, tailor your setup, and build workflows that make sense.
This topic walks through the key concepts, how they work together, and why they’re important to understand before you start hands-on setup.
### **Core Concepts In** space.vars.Kizen\_company\_name
| Concept | What It Is | How It Works | API |
|---|---|---|---|
| Object | It's like a container or a table of data that stores grouped information (such as Guests, Tickets, Staff, or Equipment). | Provides the structure for your data. space.vars.automations and space.vars.workflows reference space.vars.objects to read, update, or create information. | Use the Object endpoints to create, describe, and manage space.vars.objects. space.vars.object IDs from these endpoints are required when working with space.vars.entities, filters, and space.vars.automations. |
| Record | A single entry inside an space.vars.object (one guest, one ticket, one staff member, or one piece of equipment). | Holds the detailed information used by space.vars.workflows, charts, or space.vars.dashboards, and space.vars.activities. Most space.vars.automation logic ties back to specific space.vars.entities. | Use the Records endpoints to create, read, update, delete, and query space.vars.entities for a specific space.vars.object. Most endpoints accept space.vars.object identifiers plus filters, pagination parameters, and sorting options. |
| Activities | Past Interactions or tasks logged to a space.vars.entity (calls, notes, updates, assignments). | Build history on a space.vars.entity and can trigger space.vars.automations or appear in space.vars.dashboards and space.vars.timelines. | Use the Activities endpoints to create and fetch space.vars.activities tied to a space.vars.entity. Payloads typically include a space.vars.entity ID (or related space.vars.object/space.vars.entity reference) plus activity type, timestamp, and metadata. |
| Scheduled Activities | Future space.vars.activities with a due date or time, such as appointments, reminders, or tasks. | Drive time-based space.vars.workflows, reminders, calendar space.vars.automations, and simple to-do lists that help users manage their daily work. | Use the Activities endpoints with scheduling fields (start/due time, status). These can be combined with space.vars.automations endpoints or webhooks to react when a Scheduled space.vars.activity is created, updated, or completed. |
| Timelines | A chronological history of all interactions and space.vars.activities linked to a space.vars.entity. These can include Scheduled space.vars.activities. | Provide context for users and space.vars.automations, showing everything that has happened or will happen with that space.vars.entity in one place. | N/A |
| Agentic Workflows | Event-driven rules that move data and trigger actions, such as creating a follow-up task and sending a confirmation email when a space.vars.contact form is submitted. | Connect space.vars.objects, space.vars.entities, space.vars.activities, and external systems. Ensure processes run consistently and without manual effort. | Use space.vars.Kizen_company_name's webhook framework to trigger space.vars.automations based on events in your external systems. You can configure these webhooks to send structured payloads to space.vars.Kizen_company_name, which then starts the appropriate space.vars.workflow. |
space.vars.dashboards & Charts | Charts that show trends, performance, and operational insights. | Pull data from space.vars.objects, space.vars.entities, space.vars.activities, and space.vars.automations to help teams monitor outcomes and make decisions. | N/A |
space.vars.objects, fields, space.vars.workflows, views, and permissions.
{% endcolumn %}
{% column %}
#### **Technical Builders**
Technical Builders like developers, implementors, and solution architects extend functionality through APIs, integrations, and Marketplace tools.
{% endcolumn %}
{% endcolumns %}
A shared understanding of these building blocks ensures teams work from the same mental model.
***
## **What’s Next?**
Move into a guided walkthrough that shows how data, space.vars.objects, space.vars.workflows, and space.vars.dashboards work together in a real scenario. This example will help you see [Kizen Basics in Action](/docs/kizen-basics/kizen-in-action) and connect these concepts before you begin building in your own Business workspace.
space.vars.Theme\_park\_name is the example business we use to demonstrate how the space.vars.Kizen\_company\_name platform works in a real-world setting. Instead of learning features in isolation, you’ll follow how a single business uses space.vars.Kizen\_company\_name to connect data, manage interactions, automate operations, and support every part of its workflow.
To make the concepts concrete, you’ll track the experience of the Reyes family, a typical family visiting the park:
* **Marcus**, who plans the trip and books the tickets
* **Elena**, who manages family schedules and communicates with the park
* **Sofia (age 12)**, who needs a waiver for rides
* **Caleb (age 8)**, who signs up for park activities
As they move through the park’s online booking, entry, activities, purchases, and follow-up surveys, you’ll see exactly how space.vars.Theme\_park\_name uses space.vars.Kizen\_company\_name to support its day-to-day operations.
space.vars.Theme\_park\_name is a classic amusement park filled with roller coasters, spinning rides, carnival games, concession stands, and long summer lines. Each day, the team handles ticketing, guest requests, operations, lost items, food sales, and ongoing guest communication. This use case gives you a practical, end-to-end view of how space.vars.Kizen\_company\_name ties everything together so you can begin building your own space.vars.workflows, data structures, and space.vars.automations.
Use this walkthrough as your starting point for learning the space.vars.Kizen\_company\_name Basics: how it works, how data connects, and how you can bring all your operations into one intelligent, adaptable platform.
***
## What's Next?
Start by reviewing the [prerequisites](/docs/kizen-basics/kizen-in-action/prerequisites-or-kizen-in-action) required to complete the space.vars.Kizen\_company\_name Basics in Action walkthroughs.
# Prerequisites | Kizen Basics
Review the prerequisites required to complete the Kizen in Action walkthroughs, including account access and permissions.
## Overview
This page outlines the prerequisites required to complete the space.vars.Kizen\_company\_name Basics in Action walkthroughs. It explains the access, permissions, and environment setup you need before getting started so you can follow each example without interruption. Reviewing these requirements ahead of time helps ensure a smooth walkthrough experience as you move through the platform.
### Why This Matters
Confirming these prerequisites before starting helps prevent interruptions during the walkthrough. The examples in this guide require specific permissions and access to a Business workspace where you can safely create space.vars.objects, space.vars.activities, and space.vars.automations.
Reviewing these requirements ensures that you:
* Have the correct permissions to complete each step
* Can create and modify data structures used in the examples
* Work in a safe environment that does not affect production data
* Move through the walkthrough without needing to stop for access changes
Preparing your environment ahead of time allows you to focus on learning how the platform works rather than troubleshooting setup issues.
***
## Before You Begin
Before beginning the space.vars.Theme\_park\_name walkthrough, you **do not need prior experience** with space.vars.Kizen\_company\_name. However, you must have the following:
* **A Kizen Account:** You’ll need access to your space.vars.Kizen\_company\_name [environment](https://go.kizen.com) so you can follow along and complete each step in the example.
* **Admin Permissions:** Ensure you are and administrator and have permission to:
* View & Create space.vars.objects
* Create or Modify space.vars.activities
* Build space.vars.automations
* Create a business workspace
* Access business settings
{% hint style="info" %}
**Note:** If you don't have the correct permissions, ask your space.vars.Kizen\_company\_name admin to update your role.
{% endhint %}
* **A Test or Sandbox Workspace ****(Recommended)****:** This walkthrough uses a fictional business called space.vars.Theme\_park\_name. Using a test or sandbox workspace prevents changes from affecting your production data.
{% hint style="info" %}
**Note:** Sandbox environments can be set up by your organizations IT team.
{% endhint %}
* **Basic Understanding Of Your Own Business Data:** Understanding your data helps you apply core concepts to real business scenarios. Consider the space.vars.entities you manage, the interactions you track, and the space.vars.workflows that drive your operations.
* **Time to Follow the Walkthrough:** Plan for at least 90 minutes to complete the full example.
***
## What's Next?
Now that you have the right permissions, a test workspace, and the required setup, you’re ready to log in for the first time.
Continue to [**Logging In and Navigating the Platform**](/docs/kizen-basics/kizen-in-action/logging-in-and-navigating-the-platform-or-kizen-in-action) to learn how to sign in, explore the main navigation, and understand where core features like Data, space.vars.automations, Dashboards, and Settings live.
# Log In and Navigate the Platform | Kizen Basics
Learn how to log in to Kizen and navigate the platform, including Dashboards, data, Agentic Workflows, and Settings.
## **Overview**
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
This page introduces how to log into space.vars.Kizen\_company\_name and navigate the platform. It explains how to access your account, move through the primary navigation, and locate key areas such as space.vars.contacts, Data, Platform Tools, space.vars.activities, and Settings. Reviewing this walkthrough will help you understand how the main areas of the interface fit together before you begin creating and managing data within your Business.
### Why This Matters
Understanding how to log in and navigate the platform helps you locate the tools you’ll use throughout this guide. The main navigation provides access to your data, space.vars.workflows, space.vars.dashboards, and system configuration.
Knowing where these areas live allows you to:
* Quickly access the parts of the platform used to manage your data
* Locate tools for building space.vars.workflows, space.vars.dashboards, and integrations
* Understand where to configure settings and permissions
* Move efficiently between different parts of the platform as you build
Familiarity with the navigation makes it easier to follow the remaining walkthroughs and complete tasks without getting lost in the interface.
***
## **Before You Begin**
Before logging into space.vars.Kizen\_company\_name and navigating the platform, you must have the following:
* Your space.vars.Kizen\_company\_name [login URL](https://go.kizen.com)
* Your email and password
* A supported web browser
* Permissions for your role (Admin or Technical Builder permissions)
***
{% stepper %}
{% step %}
#### In your browser, navigate to space.vars.Kizen\_company\_name using your [Login URL](https://go.kizen.com)
space.vars.Kizen\_company\_name opens your home view or space.vars.dashboard based on your role and workspace configuration.
***
## **Exploring the Main Navigation**
The main navigation gives you access to space.vars.Kizen\_company\_name’s core features. These options appear at the top of the platform.
space.vars.dashboard
The space.vars.dashboard gives you a real-time chart view of your work with key metrics and important activity across space.vars.Kizen\_company\_name. You can use space.vars.dashboards to create and view charts that monitor performance, track progress toward goals, and quickly access the information that matters most to your role.
You can use the space.vars.dashboard to also see assigned tasks or metrics because space.vars.dashboards will display from your space.vars.contacts, space.vars.objects, space.vars.activities, space.vars.automations, and other parts of the platform. Each widget updates automatically based on the latest data in your environment.
#### **What You Can Do On The Dashboard**
1. View key metrics and performance indicators though charts
2. Place a table of space.vars.entities so you can drill into your data
3. Place a Scheduled space.vars.activities dashlet to track your tasks and upcoming work
4. Customize your view based on the kinds of charts and data you want to display
5. Monitor space.vars.automation outcomes
***
#### **Common Dashboard Examples**
The space.vars.dashboards and charts you see depend on your business setup. A few common examples include:
* **Agent or Sales Dashboard:** contains charts with upcoming tasks, lead pipelines, space.vars.contact engagement
* **Healthcare Dashboard:** contains charts with new patients, active cases, recent activities, follow-up schedules
* **Insurance Dashboard:** contains charts with quotes, enrollments, active policies, commissions progress
* **Financial Services Dashboard:** contains charts with client portfolio summaries, account activity, open opportunities
{% endtab %}
{% tab title="Data" %}
### **Data**
The **Data** menu gives you access to your core records and data tools in space.vars.Kizen\_company\_name. It includes space.vars.contactss, space.vars.objects, and space.vars.smartconnectors. Opening the **Data** menu allows you to view and manage the data you work with.
#### space.vars.contacts
[Contacts](/docs/concepts/objects/contacts) is where you can store all of your space.vars.contacts space.vars.entities. You can create new space.vars.contacts, update existing ones, upload or export space.vars.contacts using CSV files, and perform bulk actions such as sending mass emails or SMS messages. space.vars.contactss serve as the foundation for most space.vars.workflows and space.vars.automations.
#### **Objects**
[Objects](/docs/concepts/objects) let you create data structures tailored to your business. You can define objects for anything you need to track, such as companies, assets, policies, patients, equipment, events, or financial accounts. Each object has its own fields, space.vars.entities, relationships, and space.vars.automations.
#### space.vars.smartconnectors
space.vars.smartconnectors are space.vars.Kizen\_company\_name’s built-in ETL tools for importing, transforming, and loading data from external systems. You can use space.vars.smartconnectors to create repeatable data pipelines, standardize files, run SQL-based transformations, validate data, and populate one or more objects in bulk. space.vars.smartconnectors are ideal for scheduled feeds, large datasets, or complex imports that require cleanup before entering space.vars.Kizen\_company\_name.
{% endtab %}
{% tab title="Platform" %}
### **Platform**
The **Platform** tab gives you access to tools that help you communicate with your audience, collect data, manage engagement, and customize space.vars.Kizen\_company\_name’s capabilities. These features support daily operations across marketing, sales, service, and data collection.
#### **Broadcasts**
Send mass emails or SMS messages to targeted groups of space.vars.contactss. Use Broadcasts to share announcements, campaigns, reminders, or updates. You can segment your audience, schedule messages, and track engagement.
#### **Forms**
Create web forms to capture information from leads, customers, or internal teams. Form submissions automatically create or update records in space.vars.Kizen\_company\_name, making this ideal for intake workflows, lead capture, event registrations, or service requests.
#### space.vars.activities
View and manage space.vars.activities created across the platform. This includes calls, tasks, notes, messages, and any interaction logged against an space.vars.entity. From here you can create new space.vars.activities or review existing entries.
#### **App Marketplace**
Browse and install apps, plugins, and integrations that extend space.vars.Kizen\_company\_name’s functionality. The Marketplace includes quoting tools, email integrations, data loaders, developer tools, and other add-ons that connect space.vars.Kizen\_company\_name to your tech stack.
#### **Library**
Store and manage reusable content such as documents, files, templates, and media. Library items help teams standardize messaging and ensure the correct versions of assets are used throughout workflows.
#### **Surveys**
Build and distribute surveys to collect structured feedback. Survey responses can create or update records, trigger automations, or populate dashboards for analysis.
#### **Ad Manager**
Manage advertising data and connect ad campaigns to your Contacts and Objects. Use Ad Manager to track conversions, view lead performance, and connect marketing spend with outcomes inside space.vars.Kizen\_company\_name.
{% endtab %}
{% tab title="Agentic Workflows" %}
## **Agentic Workflows**
The space.vars.automations tab is where you build, manage, and monitor space.vars.automations in space.vars.Kizen\_company\_name. space.vars.automations help you streamline repetitive tasks, improve data accuracy, and ensure consistent follow-up across your business. You can create simple or advanced workflows that react to changes in your data, run on schedules, or integrate with external systems.
#### **What you can do in Agentic Workflow**s
1. Create space.vars.automations
2. Choose from multiple trigger types
3. Design custom logic
4. Send communications automatically
5. Connect to other parts of the platform
6. Monitor execution and troubleshoot issues
7. Reuse and maintain space.vars.automations
You can review your space.vars.automations to understand the automated processes in your workspace.
For more information, see [Agentic Workflows](/docs/concepts/agentic-workflows).
{% endtab %}
{% tab title="Settings" %}
### **Settings**
The **Settings** area controls your account configuration, user access, data structure, privacy rules, and integrations. Admins use this section to manage how space.vars.Kizen\_company\_name behaves for the entire organization.
#### **Business Information**
Update your company details, time zone, default formats, and communication settings.
#### **Team, Roles, & Permissions**
Add team members and manage who can view, edit, or delete data. Roles and permission sets define what each user can access across space.vars.contacts, space.vars.objects, space.vars.automations, space.vars.dashboards, and other features.
#### **Customize Fields**
Create and manage custom fields for space.vars.contacts and space.vars.objects. This helps you tailor data structures to your business needs.
#### **Domain & Tracking**
Configure domain settings and tracking preferences, including analytics, cookie/tracking behavior, and workspace URL controls.
#### **Privacy Settings**
Manage privacy and compliance options, such as data retention, consent, audit logging, and how personal data is handled.
#### **Manage Connections**
Set up and maintain integrations, API connections, and external data links. This is also where you review connection health and manage credentials used across the platform.
You can visit **Settings** to confirm your profile and permissions.
{% endtab %}
{% endtabs %}
***
## **Troubleshooting**
| Issue | What To Check |
| ---------------------------------- | -------------------------------------------------------------------- |
| You cannot sign in | Reset your password using **NEED HELP LOGGING IN?** |
| You do not see expected menu items | Your permission level may restrict visibility; contact your Admin |
| You see a blank screen or errors | Try a different browser or clear your cache |
| Navigation options look different | Your workspace may use a custom configuration or a limited role view |
***
## **What’s Next**
Now that you know how to log in and move through the main areas of space.vars.Kizen\_company\_name, you’re ready to start building your space.vars.Theme\_park\_name business. Your next step is to [Create Your First Business](/docs/kizen-basics/kizen-in-action/create-your-first-business-workspace-or-kizen-basics) which allows you to set up your workspace so you can begin managing your data in space.vars.Kizen\_company\_name.
space.vars.Kizen\_company\_name. Business workspaces allow you to store data and provides the foundation for everything you build. Creating a Business also generates a unique Business ID used for API requests and integrations. Reviewing this walkthrough will help you set up your workspace so you can begin organizing data, building space.vars.workflows, and managing operations within your Business.
### **Why This Matters**
A well-structured Business workspace ensures:
* Clean and organized data
* Accurate space.vars.workflows and space.vars.automations
* Correct role and permission behavior
* Reliable space.vars.dashboards and analytics
* A setup that scales as your organization grows
Starting with a strong Business workspace configuration reduces confusion and prevents rework later.
***
## **Before You Begin**
Most users **cannot** create a Business. You must be an Administrator with the correct permissions.
* If you’re not an Admin, ask one in your organization to create a sandbox or training workspace for you.
* If your Admin does not have permission to create a Business, contact space.vars.Kizen\_company\_name Support to have one made.
***
{% stepper %}
{% step %}
#### Select the **Profile** icon
{% endstep %}
{% step %}
#### In the dropdown menu, select **Add Business**
{% endstep %}
{% step %}
#### Enter your **Company Name** & **Business Name**
For this tutorial:
* Company Name: space.vars.Theme\_park\_name
* space.vars.Kizen\_company\_name Business Name: Flywheel - Austin Location
{% hint style="info" %}
**Note:** The Company Name field should contain your company’s legal or public name. The space.vars.Kizen\_company\_name Business Name is the name of your workspace within space.vars.Kizen\_company\_name.
{% endhint %}
space.vars.Kizen\_company\_name generate a starter Business.
{% endstep %}
{% endstepper %}
The workspace you have just created will now become your base for building, testing, and analyzing every part of your space.vars.Theme\_park\_name use case. A unique Business ID was also created which will be needed for sending API authorizations.
{% hint style="info" %}
**Note:** If you have or are creating multiple business workspaces and are building APIs in each space, you will need to the unique `X-BUSINESS-ID` string for the space you want to modify.
{% endhint %}
space.vars.workflows and space.vars.automations in space.vars.Kizen\_company\_name. Every space.vars.workflow, space.vars.automation, integration, and API interaction runs within the context of a Business.
Once a Business is created, it becomes the container where:
* space.vars.objects are defined and connected
* space.vars.activities are scheduled and logged
* space.vars.automations are triggered and executed
* Users, roles, and permissions are enforced
* External systems integrate through APIs and connectors
space.vars.workflows rely on the Business to understand *which data*, *which users*, and *which rules* apply. Without a Business, space.vars.automations have no context for where space.vars.entities live or how processes should behave.
For example, when you automate a follow-up space.vars.activity, trigger an email, or sync data from an external system, space.vars.Kizen\_company\_name uses the Business to determine:
* Which space.vars.entities to act on
* Which space.vars.workflows are allowed to run
* Which permissions apply to each action
By creating your Business first, you enable space.vars.workflows and space.vars.automations to operate consistently, securely, and at scale as your platform usage grows.
***
## Business Workspace Capabilities By Role
{% columns %}
{% column %}
#### Admins
* Create and manage Business workspaces
* Configure Business-level settings, including name, industry, and preferences
* Manage users, roles, and permissions within a Business
* Define which space.vars.objects, space.vars.activities, and features are available to teams
* Ensure data isolation and security between Business workspaces
{% endcolumn %}
{% column %}
#### Technical Builders
* Build space.vars.workflows and space.vars.automations scoped to a specific Business
* Use the unique Business ID to create API calls for creating, updating, and searching space.vars.entities
* Integrate external systems and services at the Business level
* Configure connectors, webhooks, and event-driven space.vars.workflows
* Use Business-level context to support reporting, data sync, and orchestration
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
While this guide uses a general setup example, a Business workspace in space.vars.Kizen\_company\_name maps directly to how organizations structure data, space.vars.workflows, and compliance boundaries across industries. Each Business acts as a secure, isolated environment where operations, users, and space.vars.automations are managed together.
{% tabs %}
{% tab title="Insurance" %}
In insurance, a Business workspace often represents a carrier, agency, or line of business.
Common examples include:
* Separating personal, commercial, and specialty insurance operations
* Managing multiple agencies or regions within distinct Business workspaces
* Isolating data and space.vars.workflows for compliance and regulatory requirements
By using Business workspaces, insurance teams ensure policies, claims, and client data remain properly scoped and compliant.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, a Business workspace can represent a practice, department, or care organization.
Common examples include:
* Managing separate clinics or service lines
* Isolating patient data by department or location
* Enforcing role-based access for clinical and administrative staff
Business workspaces help healthcare organizations maintain privacy, structure care space.vars.workflows, and support regulatory requirements such as HIPAA.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, a Business workspace often maps to a firm, division, or client segment.
Common examples include:
* Separating retail, wealth management, and institutional operations
* Managing multiple advisory teams or branches
* Enforcing compliance controls across accounts and space.vars.workflows
By structuring operations into Business workspaces, financial teams maintain data integrity, improve governance, and scale securely.
{% endtab %}
{% endtabs %}
***
## **What’s Next?**
Continue to [Understanding your Business Settings](/docs/kizen-basics/kizen-in-action/configure-your-business-settings-or-kizen-basics) to start modeling space.vars.Theme\_park\_name's core data. You'll use this information to set roles, permissions, and edit your business information & customizations.
# Configure Your Business Settings | Kizen Basics
Learn how Kizen administrators can configure their workspace by editing business information, adding team members, and creating roles and permission groups in the Settings area.
## Overview
Before your team begins working in space.vars.Kizen\_company\_name, an administrator needs to establish the foundations of your workspace. This topic walks you through three core setup tasks in the **Settings** area:
1. Editing your business information
2. Adding team members
3. Creating roles
Together, these tasks ensure that your workspace reflects your organization's identity, and that the right people have access.
Throughout this topic, space.vars.Theme\_park\_name is used as the example business. You will add Jacob Mulligan and Sally Woods as team members as a Guest Services and Concession Stand Cook Staff.
{% hint style="info" %}
**Note**: In this tutorial, permissions on roles and team members will not be covered. To learn more about permission basics, review [Configure Your First Permissions](/docs/kizen-basics/kizen-in-action/configure-your-first-permission-groups-or-kizen-basics).
{% endhint %}
### Why This Matters
Setting up your business information, team members, and roles correctly is not administrative overhead. It directly determines how effectively your organization operates inside the platform.
Without a clear structure:
* Users may have too much or too little access, leading to security risks or blocked space.vars.workflows
* Teams waste time navigating irrelevant data
* Reporting, ownership, and accountability become inconsistent
With a well-defined setup:
* Each team member sees only what they need, reducing errors and confusion
* Sensitive data is protected through controlled access
* space.vars.workflows run more smoothly because responsibilities and visibility are aligned
* Scaling your team becomes significantly easier since roles are already structured
This foundation ensures your workspace is not just functional, but controlled, secure, and aligned with how your business actually operates.
***
## Before You Begin
Before starting, confirm the following:
* You are logged in to space.vars.Kizen\_company\_name with an **Administrator** account. Only Admins can access and modify business settings.
* You have the full names and business email addresses of the team members you plan to add.
* Your business logo is available as an image file if you plan to upload it during the business information step.
***
## Configuring Your Business
### Task 1: Edit Your Business Information
Your business information appears throughout space.vars.Kizen\_company\_name and helps identify your workspace. Keep this information accurate so your team and any client-facing outputs reflect your brand correctly.
{% stepper %}
{% step %}
#### **Navigate to Settings using the main navigation menu.**
You'll land on **Business Information** (or Business Settings) from the **Settings** menu.
space.vars.Theme\_park\_name
Update any additional fields as needed, such as your business address, phone number, time zone, and date format preferences.
Upload your business logo if desired by selecting the logo upload area and choosing your image file.
Select **SAVE** to apply your changes.
{% endstep %}
{% endstepper %}
{% hint style="info" %}
**Note:** Timezone and date format settings affect how dates and times display across the platform for all users in your workspace. Set these carefully before your team begins logging space.vars.activity.
{% endhint %}
### Task 2: Add Team Members
Adding team members gives individuals access to your space.vars.Kizen\_company\_name workspace. Each team member is invited via email and must accept the invitation to complete account setup.
space.vars.Kizen\_company\_name to assign ownership and filter space.vars.entities.
space.vars.workflows, space.vars.automations, and users operate within.
Once configured, they influence three critical areas: **timing, communication, and user context**.
* **Timing:** space.vars.automations run based on your Business time zone. Scheduled space.vars.workflows, reminders, and space.vars.activity logging all follow this setting.
* **Communication:** Emails and messages triggered by space.vars.workflows use your Business-level defaults, such as sender address and phone configuration.
* **User context (roles and team members):** space.vars.workflows operate on space.vars.entities that are owned, updated, or assigned to specific team members.
For example:
* A space.vars.workflow that assigns a follow-up task will assign it to a **team member** with the appropriate role
* Notifications and space.vars.activities are tied to specific **users**, not just space.vars.entities
By configuring Business Settings alongside your team and roles, you ensure space.vars.workflows run correctly and reach the right people.
***
## Business Workspace Capabilities By Role
{% columns %}
{% column %}
#### Admins
* Configure Business Settings (name, branding, time zone, communication defaults)
* Add and manage team members
* Create and manage roles
* Ensure space.vars.workflows and space.vars.automations operate within the correct access boundaries
{% endcolumn %}
{% column %}
#### Technical Builders
* Build space.vars.workflows and space.vars.automations that assign tasks and update space.vars.entities based on team structure
* Use roles and user assignments to control how space.vars.automations route work
* Configure integrations that rely on Business-level context and user access
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back to Your Industry
While space.vars.Theme\_park\_name demonstrates a physical, guest-facing business, the same setup principles apply to industries where data access, compliance, and role clarity are critical.
{% tabs %}
{% tab title="Insurance" %}
In insurance organizations, teams are often divided between agents, claims processors, and underwriting staff.
* **Agents** need access to client contact space.vars.entities, policy details, and communication history, but should not have full visibility into underwriting decisions or internal financial data.
* **Claims processors** require access to claims space.vars.entities and supporting documentation, along with the ability to update claim status and timelines.
* **Underwriters** may need broader access to risk data and policy structures but limited interaction with day-to-day client communication space.vars.entities.
By defining clear roles, you ensure that sensitive financial and personal data is only accessible to those who need it, reducing compliance risk and operational errors.
{% endtab %}
{% tab title="Healthcare" %}
Healthcare organizations rely heavily on strict access controls due to patient privacy requirements.
* **Front desk staff** need access to patient intake forms, appointment records, and basic contact information.
* **Clinical staff** require access to medical records, treatment history, and care plans.
* **Billing teams** need access to insurance information and payment records but should not modify clinical data.
Using roles allows you to create distinct clinical, administrative, and financial positions. This helps maintain compliance with regulations while ensuring each team can do their job efficiently.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, teams often work across client management, compliance, and operations.
* **Advisors** need access to client profiles, portfolios, and communication history.
* **Operations teams** handle transactions, account updates, and internal space.vars.workflows.
* **Compliance teams** require visibility into activity logs and records but typically do not modify client data directly.
A structured approach to roles ensures that sensitive financial data is protected while still allowing teams to collaborate effectively. It also makes auditing and oversight significantly easier.
{% endtab %}
{% endtabs %}
***
## What's Next
Now that your workspace is configured with business information, team members, and roles, you are ready to build out the operational tools your team will use daily. Next, [Create Your First Contact Record](/docs/kizen-basics/kizen-in-action/create-your-first-contact-record-or-kizen-basics).
# Create Your First Contact Record | Kizen Basics
Learn how to create your first Contact Record in Kizen and understand how Contacts are used across Activities, Agentic Workflows, and data relationships.
## Overview
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
In space.vars.Kizen\_company\_name, a [Contact](/docs/concepts/objects/contacts) represents a single person you plan to communicate with through emails, SMS messages, or other outreach. space.vars.contacts are part of space.vars.Kizen\_company\_name’s built-in data model and work like a standard space.vars.entity type.
Email acts as the primary identifier for communication purposes, but it is not required. If left blank, it may limit certain lookup or messaging scenarios.
{% hint style="info" %}
**Note:** Storing people in space.vars.contacts allows you to **message** them through space.vars.Kizen\_company\_name’s SMS or email space.vars.automations. You should always store people as space.vars.contacts even if you don't plan to message them.
{% endhint %}
### Why This Matters
space.vars.contacts are the standard way to store people in space.vars.Kizen\_company\_name. Every individual your organization interacts with should be stored as a space.vars.contact space.vars.entity, regardless of whether you plan to communicate with them directly.
Using space.vars.contacts consistently ensures that you:
* Maintain a single, centralized space.vars.entity for each person
* Enable email and SMS space.vars.automations when communication is required
* Track activities, interactions, and history tied to that individual
* Keep operational data organized separately within space.vars.objects
As your data model grows, storing all people in space.vars.contacts helps maintain a clear structure between individuals and the operational space.vars.entities associated with them. This makes space.vars.automations, reporting, and integrations more predictable and easier to manage.
In Contacts, Email acts as the unique identifier for communication purposes — but it is **not required**, and some users may leave it blank which can cause data retrieval issues if trying to use it for anything other than messaging customers.
### Before You Begin
Before creating your space.vars.contacts, you must have the following:
* **Admin** role and permissions to create and edit space.vars.entities
* A Business workspace in space.vars.Kizen\_company\_name (See: [Create Your First Business Workspace](/docs/kizen-basics/kizen-in-action/create-your-first-business-workspace-or-kizen-basics))
***
## Meet The Reyes Family
To help you understand how space.vars.contact space.vars.entities work, we’ll follow the Reyes family, who are visiting space.vars.Theme\_park\_name for the first time. We introduced the following family in the [Kizen Basics in Action](/docs/kizen-basics/kizen-in-action) topic.
* **Marcus Reyes:** Planner of the family trip; books tickets online.
* **Elena Reyes:** Manages communication and receives all confirmation emails.
* **Sofia Reyes** *(age 12):* Loves roller coasters; needs a wristband waiver.
* **Caleb Reyes** *(age 8):* Signs up for the Junior Explorer scavenger event.
Marcus purchases tickets through the space.vars.Theme\_park\_name online form. When he submits the booking, you’ll store him as a space.vars.contact because space.vars.Theme\_park\_name needs to send him:
* A confirmation email
* Instructions on the Day of Park entry
* A survey after the visit
Elena, Sofia, and Caleb will also be stored as space.vars.contacts, even though they do not need to receive emails directly. In this lesson, you will create Marcus’ space.vars.contact space.vars.entity in space.vars.Kizen\_company\_name. You will then apply the same steps to create space.vars.contact space.vars.entity for Elena, Sofia, and Caleb.
***
## Creating Contact Records
{% stepper %}
{% step %}
#### In Kizen, navigate to **Contacts**
Select **Data** > **Contacts** in your navigation.
space.vars.contacts page appears.
{% endstep %}
{% step %}
#### Select **NEW CONTACT**
space.vars.contact we will add.
space.vars.entity.
* **Email Status:** Opt In
* This is required for messaging as all other statuses will prevent emails from being sent by space.vars.Kizen\_company\_name.
* **Home Phone:** 123-456-7890
* Not a required field, but necessary for SMS communications.
* **Custom Fields:** Any fields space.vars.Theme\_park\_name configured for guest communication.
{% hint style="info" %}
**Note:** These are fields that are customizable and can capture any field data you specify. By default Primary Company space.vars.entity and Additional Company space.vars.entities are visible. For now we will leave these blank.
{% endhint %}
For this example we will use the following:
* **Title:** Mr.
{% hint style="success" %}
Titles help you label space.vars.contacts with options like Dr., Mr., Mrs., Ms., or Miss. You can add a new one from the dropdown using **Add Title**.
{% endhint %}
* **Tags:** Leave it Blank
{% hint style="success" %}
Tags let you organize space.vars.contacts into meaningful groups, like “CloudCon 2021 Signups,” “Drip Campaign 2.1 Beta,” or “Joe’s Hand-Curated Prospects.”
{% endhint %}
* **Birthday:** 12/15/1983
* **Timezone:** America/Chicago
{% endstep %}
{% step %}
#### Select **SAVE**
After saving Marcus' space.vars.entity, you will see:
* **All visible fields:** (standard + custom)
* **Timeline:** where future activities and emails will appear
* **Activity Panel:** where staff can log calls, notes, or reminders in the future
* **Agentic Workflows:** which can send Marcus a confirmation email or create a follow-up task once it's set up.
{% endstep %}
{% endstepper %}
***
## Applying What You've Learned
With Marcus's space.vars.contact space.vars.entity complete, it’s time to create space.vars.contact space.vars.entities for the rest of the family using the same steps. Use the information below to set it up.
| Field | Elena Reyes | Sofia Reyes | Caleb Reyes |
| ----------------- | ------------------------- | ------------------------- | ------------------------- |
| **First Name** | Elena | Sofia | Caleb |
| **Last Name** | Reyes | Reyes | Reyes |
| **Email** | space.vars.contacts in space.vars.Kizen\_company\_name. By default the following columns are viewable:
* Full Name
* Email
* Mobile phone
* Titles
* Tags
Next, we are going to modify the columns to display the fields we want and in what order.
{% stepper %}
{% step %}
#### Click on **Edit Columns**
space.vars.contacts page.
space.vars.contacts page display with your new column order.
{% endstep %}
{% endstepper %}
***
## How This Fits Into Agentic Workflows
Now that you’ve added Marcus Reyes and customized your space.vars.contact table view, the next step is to add the rest of the Reyes family as space.vars.contact space.vars.entities.
Even if Elena, Sofia, and Caleb are not the recipients of emails or SMS messages, they should still be stored as space.vars.contacts because they represent real people tied to park operations and guest history. In space.vars.Kizen\_company\_name, a space.vars.contact can exist without being used for messaging.
As you add Elena, Sofia, and Caleb Reyes:
* Create one space.vars.contact per person
* Leave Email blank for family members who should not receive communications
* Set messaging-related fields (such as Email Status) according to your business rules
* Use consistent names and information (like phone number or address) so the family can be associated correctly in later steps
When you finish, you should have four space.vars.contact space.vars.entities:
* Marcus Reyes (primary communication space.vars.contact with an email listed)
* Elena Reyes
* Sofia Reyes
* Caleb Reyes
space.vars.contacts to operational records such as tickets and space.vars.activities.
***
## How This Fits Into Agentic Workflows
As soon as Marcus and his family becomes a space.vars.contact, space.vars.Kizen\_company\_name can:
* Send a confirmation email
* Trigger a welcome SMS
* Create a pre-visit task for staff
* Add Marcus or his family to an email drip sequence
* Kick off space.vars.workflows tied to space.vars.contact creation
Adding people to space.vars.contacts also allows you to later build space.vars.automations such as:
* Sending reminders
* Assigning space.vars.activities
* Creating Scheduled space.vars.activities
* Tracking guest history
* Building space.vars.dashboards of guest engagement
***
## Contact Capabilities By Role
{% columns %}
{% column %}
#### **Admins**
* Configure space.vars.contact fields
* Manage permissions
* Set up space.vars.workflows and space.vars.automations connected to space.vars.contacts
{% endcolumn %}
{% column %}
#### **Technical Builders**
* Use [Objects APIs](/docs/concepts/objects/object-apis) to create or update space.vars.contact space.vars.entities programmatically
* Configure inbound webhooks when space.vars.contacts originate from external forms or systems
* Map incoming data to the space.vars.contact space.vars.object through ETL or integration tools
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
While the Reyes family example demonstrates how space.vars.contacts work in a theme park scenario, the same concepts apply across industries. A space.vars.contact is simply a space.vars.entity representing a person, whether you communicate with them directly through email, SMS, or automated space.vars.workflows, or not.
How you structure your [Contact Data Model](/docs/concepts/objects/contacts/contacts-data-model) determines how easily your organization can manage communication, track interactions, and automate processes as your system grows.
Below are examples of how space.vars.contacts function in three common industries supported by space.vars.Kizen\_company\_name.
{% tabs %}
{% tab title="Insurance" %}
In insurance, a space.vars.contact often represents a policyholder, applicant, or agent who needs to receive quotes, renewal notices, eligibility updates, or claims communications.
Example space.vars.contact space.vars.automations:
* Email a quote packet after an application is submitted
* Notify an agent when underwriting status changes
* Send renewal reminders or required-document checklists
* Trigger tasks for claims adjusters or verification teams
Use space.vars.objects to store structured data like applications, policies, beneficiaries, claims, and supporting documents, while space.vars.contacts remain the communication endpoint.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, a space.vars.contact often represents a patient, caregiver, or responsible party who must receive appointment reminders, care instructions, follow-up messages, or portal notifications.
Example space.vars.contact space.vars.automations:
* Send pre-visit instructions when a patient books an appointment
* Trigger SMS reminders 24 hours before a procedure
* Log follow-up calls or care-team activities directly on the space.vars.contact timeline
* Send discharge instructions or satisfaction surveys automatically
Use space.vars.contacts when communication is required. Use space.vars.objects for clinical space.vars.workflows like care plans, intake forms, encounters, or orders that you don’t message directly.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, a space.vars.contact typically represents a client, borrower, investor, or account holder who needs time-sensitive updates or required disclosures.
Example space.vars.contact space.vars.automations:
* Send onboarding emails after a new account is created
* Trigger reminders for outstanding documentation
* Log advisor calls or follow-up tasks
* Send periodic statements, alerts, or investment updates
space.vars.objects store operational data such as accounts, transactions, loans, risk reviews, or KYC/AML space.vars.entities, while space.vars.contacts manage all direct communication.
{% endtab %}
{% endtabs %}
***
## What’s Next?
Now you’ll begin building the foundation of space.vars.Kizen\_company\_name’s data model. In [Create Your First Object](/docs/kizen-basics/kizen-in-action/create-your-first-object-or-kizen-basics), you will first create a Tickets space.vars.object to track purchases like Marcus’s park tickets. You will then create Concessions and Ride Waiver space.vars.objects to track food and merchandise purchases and store ride waiver information for guests.
# Create Your First Object | Kizen Basics
Learn how to create your first Object in Kizen and understand how custom data structures support & Agentic Workflows.
## Overview
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
In space.vars.Kizen\_company\_name, an space.vars.object is like a table or a data container that you create to store and organize the data that matters to your business. space.vars.objects hold the space.vars.entities you’ll reference in space.vars.automations, space.vars.dashboards, and space.vars.workflows. space.vars.contacts store the people you need to communicate with, space.vars.objects store everything else — tickets, ride waivers, concessions, assets, tasks, memberships, and more.
In this walkthrough, you’ll create three space.vars.objects for space.vars.Theme\_park\_name:
* **Tickets Object:** to store ticket purchases and visitor passes, such as Marcus’s family admission
* **Concessions Object:** to capture food and merchandise purchases made during park visits
* **Ride Waiver Object:** to store and track ride waivers signed by guests
These space.vars.objects will become the foundation for your next steps, including creating space.vars.entities and building space.vars.workflows that automate communication, follow-up tasks, and daily park operations.
### Why This Matters
space.vars.objects define where your data lives and how it’s structured. Clear space.vars.object design prevents errors later, such as:
* space.vars.workflows not triggering correctly
* space.vars.automations missing required fields
* Reports failing to show accurate information
* Disorganized or duplicated data across your business
A well-planned space.vars.object gives your team a consistent, scalable data foundation. Now, lets start by creating your **Tickets** space.vars.object.
### Before You Begin
Before creating an space.vars.object, you must have the following:
* **Admin** permissions with the ability to create and edit space.vars.entities
* A Business workspace created
***
{% stepper %}
{% step %}
#### Navigate to **Objects**
space.vars.contact space.vars.entities to store information about each member of the family.
Now, you will create a **Tickets Object** to store ticket purchases made for park visits. This space.vars.object will define the structure used to capture purchases, such as who bought the tickets, how many were purchased, and the date of the visit.
{% hint style="info" %}
**Note:** In later steps, you will create Ticket space.vars.entities within this space.vars.object to track purchases like the one Marcus made for his family.
{% endhint %}
First, select the **NEW OBJECT** button. You will be taken to the General Settings page for your space.vars.object.
{% endstep %}
{% step %}
#### Fill out the **General Settings** page
space.vars.object and represents the type of data you’re tracking. An space.vars.object is like a table or container, so this name describes the collection of space.vars.entities it will hold.
{% endhint %}
* **Record Name:** Ticket
{% hint style="info" %}
**Note:** This is the name you want to call an individual space.vars.entity in your space.vars.object. Remember, this is a specific space.vars.entity inside of your collection of data. Currently, this is called **Entity Name** in the UI.
{% endhint %}
* **Contains Workflow:** Disable
{% hint style="info" %}
**Note:** This feature is used for creating opportunity or deal pipelines and ticket workflows. We won’t use it in this example, but you’ll learn how it works in the [Create Your First Workflow](/docs/kizen-basics/kizen-in-action/create-your-first-workflow-or-kizen-in-action) topic.
{% endhint %}
* **Enable Quick Filters:** Disable
* **Object Description:** Stores space.vars.entities of ticket purchases made for park visits. This space.vars.object tracks details such as the purchaser, number of tickets, visit date, and other information related to admission.
* **Enable Activities:** Enabled
* **Track Track Entity $ Value:** Enabled
{% endstep %}
{% step %}
#### Select **SAVE & CONTINUE**
This will automatically save your space.vars.object and take you to the Related space.vars.objects step below.
{% hint style="info" %}
**Note:** The Contacts relationship appears by default but isn't saved until you select **SAVE & CONTINUE.**
{% endhint %}
space.vars.object and his space.vars.contact information in the space.vars.contacts space.vars.object so we can keep track of who purchased what tickets. To do this, under **Related Objects.**
Then enter the following:
* **Related Object:** Contacts
* **Relationship Type:** Many-to-One
* **Relationship Name:** Purchaser Contact
* **Reverse Relationship Name:** Related Ticket Records
space.vars.field acts like a column in your table of data inside your space.vars.object. As you can see, when you created your space.vars.object, space.vars.Kizen\_company\_name automatically created table columns for you.
space.vars.Kizen\_company\_name automatically creates the **Ticket Name** field as the unique identifier for this space.vars.object.
{% endhint %}
Now, we will create new column data. Select **+ADD NEW FIELD** and create the following so we can properly capture your Ticket data. Add the following fields:
{% hint style="info" %}
**Note:** That you do not need to change the **Category** or **Description Visibility** settings for this example.
{% endhint %}
space.vars.entities how many admissions were purchased for the visit. |
| **Admission Status** | Indicates whether the ticket has been used for entry. | Dropdown. (Unused,Used) | Tracks whether the ticket has been used or is still unused. |
| **Purchase Method** | Tracks how the tickets were purchased. | Dropdown (Online, In Person, Telephone | Identifies the source of the purchase, such as Online or In Person. |
All new space.vars.fields should be visible in your Ticket info category including the relationship field you created in step 2.
space.vars.fields by category.
{% endhint %}
{% endstep %}
{% step %}
#### Select **Default Columns** tab from **Step 4 Customize Layout**
Here is where you can take the space.vars.fields you just created and then organize them on your Ticket Overview table.
space.vars.contact
* Visit Date
* Number of Tickets
* Admission Status
* Purchase Method
Lets remove the columns we don't need that came standard with the Tickets space.vars.object.
* Owner
* Display Name
* Last Modified
{% endstep %}
{% step %}
#### Select **SAVE & CLOSE**
space.vars.object is now ready to store space.vars.entities and support space.vars.workflows later in the walkthrough.
{% endstep %}
{% endstepper %}
***
## Apply What You've Learned
With the Tickets space.vars.object now complete, it’s time to apply what you have learned to create Concessions and Ride Waiver space.vars.objects using the same steps. These space.vars.objects will track purchases made in the park and adherence to safety policies.
Use the information below to set it up.
* **Object Name:** Concessions
* **Record (Entity) Name:** Concession
* **Enable Workflows:** Disable
* **Enable Quick Filters:** Disable
* **Object Description:** Stores records of concession purchases, including the product purchased, purchase date, visit date, and the Contact who made the purchase.
* **Enable Activities:** Enabled
* **Track Track Entity $ Value:** Enabled
#### Create Your Fields For The Concessions Object
{% hint style="info" %}
**Note:** For this example **do not** modify the Category or Description Visibility fields.
{% endhint %}
| Field Name | Description | Field Type | Field Purpose |
| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Concession Name** *(Unique Identifier)* | A unique name for the concession purchased | Text (Unique Identifier) | Identifies the concession purchase space.vars.entity within the Concessions space.vars.object. |
| **Concession Value** | The total cost of the concession purchase. | Currency | Tracks the revenue generated from the purchase. |
| **Primary Contact** | The space.vars.contact space.vars.entity of the person who made the purchase. | Relationship (Contacts) | Links the concession purchase to the person responsible for the order. |
| **Purchase Date** | The date the concession item was purchased. | Date/Time | Tracks when the purchase occurred. |
| **Quantity** | The number of items purchased. | Number (Whole) | Captures how many units of the item were purchased. |
#### Customize Your Default Columns
Now Navigate to **Customize Layout** > **Default Columns** and move your columns as follows
{% columns %}
{% column %}
#### Available Columns
Owner
Date Created
Display Name
Last Modified
{% endcolumn %}
{% column %}
#### Active Table Columns
Concession Name
Concession Value
Primary space.vars.contact Record
Purchase Date
Quantity
{% endcolumn %}
{% endcolumns %}
Select **SAVE & CONTINUE**, then **FINALIZE YOUR OBJECT** (you do not need to set permissions at this time). Now your **Concessions** space.vars.object is now ready for space.vars.entity creation and space.vars.automation triggers (such as sending confirmation messages or creating follow-up tasks)!
space.vars.object for ride waivers and use the information below to set it up.
* **Object Name:** Ride Waivers
* **Record (Entity) Name:** Ride Waiver
* **Enable Workflows:** Disable
* **Enable Quick Filters:** Disable
* **Object Description:** Stores space.vars.entities of ride waivers signed for park attractions, including the ride name, waiver date, visit date, and the space.vars.contact associated with the waiver.
* **Enable Activities:** Enabled
* **Track Track Entity $ Value:** Disabled
| Field Name | Description | Field Type | Field Purpose |
| ------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Ride Waiver Name** *(Unique Identifier)* | A unique name for the waiver space.vars.entity. | Text (Unique Identifier) | Identifies the waiver space.vars.entity within the Ride Waiver space.vars.object. |
| **Guest Record** | The space.vars.contact space.vars.entity of the guest who requires the waiver. | Relationship: Contacts | Links the waiver to the individual guest participating in the ride. |
| **Ride Name** | The name of the ride requiring the waiver. | Text | Identifies which attraction the waiver applies to. |
| **Waiver Date** | The date the waiver was signed or approved. | Date/Time | Tracks when the waiver was completed. |
| **Visit Date** | The date of the park visit is associated with the waiver. | Date | Links the waiver to a specific park visit. |
| **Waiver Status** | Indicates whether the waiver has been signed and approved. | Dropdown (Pending, Signed, Verified) | Tracks whether the guest has completed the required waiver. |
| **Guardian Contact** | The space.vars.contact space.vars.entity of the parent or guardian who signed the waiver. | Relationship: Contacts | Captures who approved the waiver if the guest is a minor. |
Ensure that you have customized your fields so only the ones shown above are visible!
space.vars.Theme\_park\_name has Tickets, Concessions, and Ride Waiver space.vars.objects, space.vars.Kizen\_company\_name can begin connecting real processes to the Reyes family’s visit. Each space.vars.object captures a different part of the guest experience, from ticket purchases, to food purchases, to required ride permissions.
When Marcus’s Ticket space.vars.entity is created, it becomes the event that starts everything:
* A welcome email is sent
* Staff are assigned tasks
* Ride Waivers are sent out and wristbands are prepared
* A follow-up survey is scheduled
These space.vars.workflows and space.vars.automations work best when the underlying space.vars.objects and space.vars.entities are structured correctly, which is why defining these space.vars.objects is an essential step before [Creating Your First Workflow](/docs/kizen-basics/kizen-in-action/create-your-first-workflow-or-kizen-in-action).
***
## Object Capabilities By Role
{% columns %}
{% column %}
#### **Admins**
* Create and manage space.vars.objects
* Add or modify fields
* Control permissions and relationships between space.vars.object
* Prepare data structures for space.vars.workflows, space.vars.dashboards, and space.vars.automations
{% endcolumn %}
{% column %}
#### **Technical Builders**
* Integrate external systems using webhooks or ETL pipelines to populate space.vars.object
* Leverage space.vars.entity-level APIs to sync tickets and guest data from other platforms
* Build scalable data models with future space.vars.automations in mind
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
The three space.vars.objects you created for the Reyes family are specific to space.vars.Theme\_park\_name, but the same structure applies across many industries. space.vars.objects are how you model your business — they represent the data you track, the processes you automate, and the relationships your space.vars.workflows depend on.
Below are examples of how the concepts in this walkthrough translate into real-world use cases in Healthcare, Insurance, and Financial Services.
{% tabs %}
{% tab title="Insurance" %}
In insurance, space.vars.objects represent the structured data and processes that define underwriting, quoting, policy management, and claims.
Common space.vars.objects include:
* Applications
* Policies
* Vehicles, Properties, or Insured Assets
* Claims
* Beneficiaries
* Supporting Documents
Industry parallels to the space.vars.Theme\_park\_name setup:
* Tickets space.vars.object → Policy or Quote space.vars.entities linked to a space.vars.contact (applicant)
* Concessions space.vars.object → Transactions related to a policy, such as premium payments, service fees, or endorsements
* Ride Waivers space.vars.object → Signed disclosures, acknowledgments, or compliance documents required for coverage
space.vars.objects allow insurers to:
* Trigger space.vars.workflows when an application is submitted
* Route tasks to underwriting or claims teams
* Generate policy documents
* Automate renewal reminders
* Track multi-step processes with full audit history
Just like space.vars.Theme\_park\_name uses Tickets to start visit space.vars.workflows, an Application or Claim space.vars.object can trigger space.vars.automations that route work through the appropriate teams.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, space.vars.objects often represent operational or clinical data that is not tied to direct communication. While a patient might exist as a space.vars.contact, much of the supporting information is better stored in space.vars.objects such as:
* Appointments
* Care Plans
* Intake Forms
* Encounters / Visits
* Orders, labs, or imaging requests
* Authorizations or referrals
Industry parallels to the space.vars.Theme\_park\_name setup:
* Tickets space.vars.object → Appointment or Visit space.vars.entities associated with a patient
* Concessions space.vars.object → Billing or charge space.vars.entities for services, medications, or procedures
* Ride Waivers space.vars.object → Consent forms, treatment authorizations, or liability waivers signed before care
space.vars.objects allow healthcare teams to:
* Track appointment details and provider assignments
* Run space.vars.automations for check-in space.vars.workflows
* Trigger tasks for pre-visit requirements (forms, documentation, prep)
* Schedule follow-up activities or compliance reminders
Just like Tickets trigger space.vars.workflows at space.vars.Theme\_park\_name, a Visit space.vars.entity can trigger automated pre-visit instructions, reminders, and post-visit follow-ups.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, space.vars.objects structure the core data that supports compliance, relationship management, and account operations.
Typical space.vars.objects include:
* Accounts
* Transactions
* Loan Applications
* Investments or Holdings
* KYC/AML Reviews
* Risk Profiles
Industry parallels to the space.vars.Theme\_park\_name setup:
* Tickets space.vars.object→ Account, loan, or investment application space.vars.entities tied to a client engagement
* Concessions space.vars.object→ Transaction space.vars.entities such as deposits, withdrawals, fees, or trade activity
* Ride Waivers space.vars.object → Signed disclosures, risk acknowledgments, or compliance documents required for financial services or investment activities
space.vars.objects help financial institutions:
* Run onboarding space.vars.workflows when a new account is created
* Validate required documentation
* Trigger advisor tasks
* Automate compliance reviews
* Track transaction-related activities
Just like Tickets drive visit preparation at space.vars.Theme\_park\_name, a Loan Application or New Account space.vars.object can drive automated review steps, outreach, reminders, and approval space.vars.workflows.
{% endtab %}
{% endtabs %}
***
## What’s Next?
Now that your Tickets, Concession, and Ride Waiver space.vars.objects are created, you’re ready to add real data to your workspace. In the next topic, [Create Your First Record](/docs/kizen-basics/kizen-in-action/create-your-first-record-or-kizen-basics), you’ll enter the following space.vars.entities:
* Marcus’s purchased ticket into the Tickets space.vars.object
* The Reyes family snack purchase in the Concessions space.vars.object
* Sofia’s ride waiver in the Ride Waiver space.vars.object
These space.vars.entities will prepare your workspace for building your first space.vars.workflow, where the system can trigger actions such as sending confirmations, creating tasks, or tracking guest activities.
# Create Your First Record | Kizen Basics
Learn how Records work in Kizen Objects. Create, structure, and connect Record data to power Agentic Workflows, Activities, reporting, and enterprise operations.
## **Overview**
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
Now that you’ve created your space.vars.objects, it’s time to add your first space.vars.entities to them. In space.vars.Kizen\_company\_name, a [Record](/docs/concepts/objects/records) is a single entry of data inside an space.vars.object. It works similar to a row in a table, and stores all the information related to your space.vars.object grouping.
For example, if your space.vars.object is a collection of ticket data, then a space.vars.entity would be all the data associated with one ticket or one purchase of tickets. The fields you define in your space.vars.object shape what data each Record contains.
In this topic, we continue following the Reyes family on their first visit to space.vars.Theme\_park\_name. Your next step is to store Marcus’ Ticket purchase in the Tickets space.vars.object, then connect the ticket data back to the family's space.vars.contact space.vars.entity. You will:
* Learn to create **Ticket** space.vars.object Data
* Learn how fields determine what data each space.vars.entity can hold
* See how space.vars.entity structure supports Workflows, Activities, space.vars.automations, and reporting
* Apply those same steps to create data for the **Concessions** space.vars.object and **Ride Waiver** space.vars.object
These space.vars.entities become the foundation for all operational processes in space.vars.Theme\_park\_name and in your own business use cases.
### **Why This Matters**
Well-structured space.vars.entities impact nearly everything in space.vars.Kizen\_company\_name, including:
* **Accuracy:** Clear fields prevent missing or duplicated data, for example, a dropdown for Stage Status ensures staff select *Searching* rather than typing it freehand.
* **Agentic Workflows:** space.vars.workflows depend on consistent field values to trigger correctly, such as sending a notification only when Stage Status changes to *Located.*
* **Reporting:** space.vars.dashboards and filters rely on clean, meaningful fields, a mislabeled stage can cause requests to disappear from operational reports.
* **Scalability:** Good space.vars.entity structure grows with your operations without requiring rebuilds as processes expand.
* **Activities:** Logged or scheduled tasks pull data directly from space.vars.entities, so a missing space.vars.contact field means staff can't follow up automatically.
When your space.vars.entities are organized correctly, space.vars.workflows run without errors and your operational data tells a trustworthy story.
***
## **Before You Begin**
To complete this task, you must:
* Have permissions to create and edit space.vars.entities on the space.vars.objects you are modifying.
* Have completed:
* [Create Your First Contact Record](/docs/kizen-basics/kizen-in-action/create-your-first-contact-record-or-kizen-basics)
* [Create Your First Object](/docs/kizen-basics/kizen-in-action/create-your-first-object-or-kizen-basics)
* You should also have three space.vars.objects already created:
* **Tickets** for Marcus' purchase
* **Concessions** for future food and snack purchases
* **Ride Waivers** to capture permission forms the family must sign.
* You should also have space.vars.contact space.vars.entities for all four family members
***
{% stepper %}
{% step %}
#### In the top navigation, select **Data** > **Custom Objects**
space.vars.entities yet.
{% endhint %}
{% endstep %}
{% step %}
#### Create a new space.vars.entity
Select **NEW TICKET**
space.vars.object.
{% endstep %}
{% endstepper %}
***
## **Apply What You’ve Learned**
Next, you’ll create a **Concession** space.vars.entity using the same steps you used for the **Ticket** space.vars.entity you set up earlier.
{% stepper %}
{% step %}
#### Navigate back to the **Objects** page
Select **BACK TO OBJECTS** to return to the space.vars.objects page.
space.vars.object will navigate you to the Concession space.vars.entities page.
{% endstep %}
{% step %}
#### Enter your Record data
Select **NEW CONCESSION** and enter the following information.
* **Concession Name:** Popcorn
* **Owner:** Yourself
* **Concession Value:** $7.50
* **Primary Contact Record:** Sofia Reyes
* **Quantity:** 1
* **Purchase Date:** 6/15 at 2:30pm
{% endstep %}
{% step %}
#### Now, enter data for 3 other concessions
The data for the next three concessions can be found in the expanders below.
space.vars.entitys are now fully configured and connected.
***
## How Records Power Agentic Workflows
Well-structured space.vars.entities are the foundation of every space.vars.workflow and space.vars.automation. Now that your **Ticket, Concessions,** and **Ride Waiver** space.vars.entities exist, the system can begin connecting operational processes to the Reyes family’s visit.
These space.vars.entities can trigger automated actions such as:
* Sending Marcus a ticket purchase confirmation email
* Scheduling a reminder email the day before the family’s visit
* Logging concession purchases during the park visit
* Recording Sofia’s completed ride waiver for staff verification
* Updating space.vars.timelines and related space.vars.entities automatically as new activities occur
In the next lesson, you’ll build your first space.vars.workflow, using a Support Ticket space.vars.entity as the trigger event.
### **Record Capabilities by Role**
{% columns %}
{% column %}
#### **Admins**
* Create, edit, reorder, and delete fields
* Modify space.vars.entity layouts
* Configure relationships between space.vars.objects
* Manage permissions for space.vars.entity editing
{% endcolumn %}
{% column %}
#### **Technical Builders**
* Use the space.vars.entities API to create, update, or retrieve space.vars.entities programmatically
* Build integrations using webhooks
* Map external data sources into space.vars.objects
* Create scalable schemas that support complex space.vars.automations
{% endcolumn %}
{% endcolumns %}
***
## Industry Applications
space.vars.entities aren’t just for theme parks. In other industries, the same concepts apply.
{% tabs %}
{% tab title="Insurance" %}
In insurance, space.vars.entities represent the individual entries stored within each space.vars.object. These space.vars.entities capture the specific details for applications, policies, claims, and other operational data used by insurers.
Common space.vars.entities include:
* Applications
* Policies
* Claims
* Insured items
* Beneficiaries
Industry parallels to the space.vars.Theme\_park\_name setup:
* **Guests Record** → Individual insured persons, dependents, or covered members
* **Ticket Record** → A policy or quote space.vars.entity created for a customer
These space.vars.entities allow insurers to:
* Track the details of individual applications, policies, and claims
* Capture information about insured assets or beneficiaries
* Maintain operational history for underwriting and servicing activities
Just as space.vars.Theme\_park\_name stores ticket purchases as space.vars.entities, insurance systems store applications, policies, and claims as space.vars.entities within their respective space.vars.objects to support business operations.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, space.vars.entities represent the individual entries stored within each space.vars.object. These space.vars.entities capture the details of patient interactions, clinical activities, and operational processes that occur throughout the care lifecycle.
Common space.vars.entities include:
* Appointments
* Visits or patient encounters
* Intake forms
* Care plans
* Orders or referrals
Industry parallels to the space.vars.Theme\_park\_name setup:
* **Guest Record** → A patient or individual receiving care
* **Ticket Record** → A visit or appointment space.vars.entity associated with that patient
These space.vars.entities allow healthcare organizations to:
* Track scheduled appointments and completed visits
* Capture patient intake information and care plans
* Manage referrals, orders, and follow-up care activities
Just as space.vars.Theme\_park\_name stores ticket purchases as space.vars.entities, healthcare systems store appointments, visits, and care activities as space.vars.entities within their respective space.vars.objects to manage patient care and operational space.vars.workflows.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, space.vars.entities represent the individual entries stored within each space.vars.object. These space.vars.entities capture the details of client accounts, financial transactions, and operational processes that occur across banking, lending, and investment services.
Common space.vars.entities include:
* Accounts
* Transactions
* Loan applications
* KYC (Know Your Customer) checks
* Investment portfolios
Industry parallels to the space.vars.Theme\_park\_name setup:
* **Guest Record** → A client or account holder
* **Ticket Record** → A loan application, account opening, or investment request associated with that client
These space.vars.entities allow financial institutions to:
* Track client accounts and financial activity
* Capture loan applications and verification details
* Maintain compliance space.vars.entities such as KYC documentation
* Manage investment portfolios and related transactions
Just as space.vars.Theme\_park\_name stores ticket purchases as space.vars.entities, financial systems store accounts, transactions, and applications as space.vars.entities within their respective space.vars.objects to support financial operations and regulatory compliance.
{% endtab %}
{% endtabs %}
***
## **What’s Next**
Now that you’ve created your first space.vars.entitys, the next step is learning how to build a space.vars.workflow. In [Create Your First Workflow](/docs/kizen-basics/kizen-in-action/create-your-first-workflow-or-kizen-in-action)**,** you’ll create a space.vars.workflow space.vars.object that tracks operational processes and moves records through defined stages.
For example, when Sofia realizes she left her backpack near one of the rides, park staff create a Lost Item Request that moves through stages such as *Reported*, *Searching*, and *Resolved*, ensuring the right staff members take action at each step.
# Configure Your First Permission Groups | Kizen Basics
Learn how to create permission groups and apply object-level access in Kizen to control what your team can see, edit, and delete.
## Overview
In space.vars.Kizen\_company\_name, a **Permission Group** defines what your team members can see and do across your workspace, from top-level features like space.vars.dashboards and space.vars.automations, down to individual fields on a space.vars.entity. By default, a new space.vars.object is not accessible by any permission group except the Administrator. You must explicitly create a group and apply a permission set to it for your team to gain access.
In this walkthrough, you'll complete two tasks for space.vars.Theme\_park\_name:
* **Create a permission group** called *Flywheel Guest Staff* from the Settings area
* **Apply a permission set** to the Tickets space.vars.object so that group can access ticket space.vars.entities
### Why This Matters
Permission groups define who can interact with your data and how. Skipping this setup, or doing it after your team is already working, can cause issues such as:
* Team members accessing or editing space.vars.entities they shouldn't
* space.vars.automations routing work to users without the access needed to act on it
* Bulk actions like exporting or archiving being performed by unauthorized staff
* Sensitive field data being visible to the wrong people
A well-configured permission group protects your data and keeps your space.vars.workflows running as intended.
***
## Before You Begin
Before creating a permission group, you must have the following:
* **Admin access** to your space.vars.Kizen\_company\_name workspace. Only Admins can access the Settings area and manage permission groups.
* **Your Objects already created.** The Add Permission Group modal lists all existing space.vars.objects, including Tickets, Concessions, and Ride Waivers. Create these space.vars.objects before building your group. If you haven't created your space.vars.objects yet, see [Create Your First Object](/docs/kizen-basics/kizen-in-action/create-your-first-object-or-kizen-basics) before continuing.
{% hint style="info" %}
**Note:** You can create and configure a permission group before adding team members. Team members can be assigned to the group at any time.
{% endhint %}
***
## Business Settings Capabilities by Role
In space.vars.Kizen\_company\_name, only Admins can access and configure the Settings area. All other roles interact with the workspace within the boundaries Admins define.
| Capability | Admin | Flywheel Guest Staff | Flywheel Concession Staff |
| ----------------------------------------------------------------------------- | ----- | -------------------- | ------------------------- |
| Create and manage permission groups | ✅ | ❌ | ❌ |
| Configure space.vars.object-level permissions | ✅ | ❌ | ❌ |
| Access Settings area | ✅ | ❌ | ❌ |
| Access Tickets space.vars.object | ✅ | ✅ | ❌ |
| Access Concessions space.vars.object | ✅ | ❌ | ✅ |
| Edit associated space.vars.entities | ✅ | Tickets only | Concessions only |
| Delete or archive space.vars.entities | ✅ | ❌ | ❌ |
| Export space.vars.entities to CSV | ✅ | ❌ | ❌ |
***
## Create the Flywheel Guest Staff Permission Group
{% stepper %}
{% step %}
#### In the top navigation, select **Settings**.
Select **Team, Roles, & Permissions**.
{% endstep %}
{% step %}
#### Select the **Permission Groups** tab.
Select **New Permission Group**.
space.vars.Kizen\_company\_name, including top-level features and each of your space.vars.objects.
{% endstep %}
{% step %}
#### Name Your Permission Group
At the top of the modal, enter *Flywheel Guest Staff*.
space.vars.Kizen\_company\_name the group can access, each with a toggle to enable or disable access. Some areas, like Homepage, space.vars.object Settings, Notification Center, Teams, and App Marketplace, also include granular Permission Area controls with None, View, Create/Edit, and Delete/All options.
Enable only the following for Flywheel Guest Staff, and leave everything else **off**:
| Area | Setting |
| ------------------------------------------------------------------ | ------- |
| Custom space.vars.object - Tickets | On |
| Teams - My Profile | On |
| {% endstep %} | |
{% step %}
#### Configure Permission Set
When you toggle **Custom Object - Tickets** on, the space.vars.object expands to reveal its full permission set. Configure the permissions as the following (there should be nothing past the **Create/Edit** level):
space.vars.Theme\_park\_name Guest Staff and the Tickets space.vars.object are configured, use the same steps to create a second permission group called Flywheel Concession Staff and configure its access to the Concessions space.vars.object.
### Create the Flywheel Concession Staff Permission Group
Follow the same steps in to create a new permission group. Name it *Flywheel Concession Staff* and enable only the following, leaving everything else off:
| Area | Setting |
| --------------------------------------------------------------- | ------- |
| space.vars.object - Concessions | On |
| Teams - My Profile | On |
### Apply a Permission Set to the Concessions Object
Configure the following permission sets: **All Concessions Records, Record Overview, Perform Single Record Actions, Perform Bulk Actions, Individual Concessions Field Permissions, Concession Info**
Align it with the permission set of Flywheel Guest Staff; the difference is, you're configuring the **Custom Object - Concessions** instead of **Custom Object - Tickets,** so there will be some different permissions to configure.
Once complete, select **SAVE**.
When you're finished, it should look like this:
space.vars.automations in Kizen run independently of permission groups; they execute regardless of a user's access level. Where permissions matter is after the handoff: when an space.vars.automation assigns a space.vars.entity or task to a team member, their permission group determines what they can actually do with it. Getting this right before you build your space.vars.automations means the handoff works as intended every time.
For example:
* If a ticket purchase triggers an space.vars.automation that asks guest staff to verify admission status, they can update that field only if their permission group allows Create/Edit access on it
* If concession staff need to log a purchase mid-visit, their group must have Create New Concessions space.vars.entities enabled for the space.vars.entity to save correctly
* If concession staff shouldn't be able to export purchase data — protecting guest spending information — leaving Export to CSV set to None enforces that boundary automatically
Well-configured permission groups mean your space.vars.automations run without hitting access errors, and your data stays protected at every step.
***
## Tying It Back to Your Industry
Configuring permission groups is a requirement across regulated and operationally complex industries, and not just theme parks. Below are examples of how this setup translates into real-world use cases.
{% tabs %}
{% tab title="Insurance" %}
In **insurance**, separate permission groups ensure that claims staff, underwriters, and account managers each see only the space.vars.objects and fields relevant to their work.
* A Claims Adjuster group might have Create/Edit access on claim space.vars.entities they are associated with, but View-only access on all claims, which prevent cross-account edits
* An Underwriting group might have access to policy and application space.vars.objects but no access to claims data
* Sensitive fields like settlement amounts or fraud flags can be restricted to None for front-line staff while remaining visible to managers
{% endtab %}
{% tab title="Healthcare" %}
In **healthcare**, permission groups protect patient space.vars.entities and ensure staff only access data relevant to their care responsibilities.
* An Intake Staff group might have access to intake form and appointment space.vars.objects but no visibility into care plan or billing space.vars.entities
* A Billing group might have access to charge and transaction space.vars.objects but no access to clinical documentation
* Field-level restrictions ensure sensitive data like diagnosis codes or treatment notes are visible only to clinical roles
{% endtab %}
{% tab title="Financial Services" %}
In **financial services**, permission groups enforce the access boundaries required for compliance and client data protection.
* A Loan Officer group can be scoped to loan application space.vars.objects, with no access to investment or account management data
* A Compliance group might have View-only access across all space.vars.objects for audit purposes, without the ability to edit or delete any space.vars.entities
* Keeping Export to CSV disabled for most groups prevents unauthorized extraction of client financial data
{% endtab %}
{% endtabs %}
***
## What's Next
Now that your permission groups are created and your Tickets and Concessions space.vars.objects have permissions configured, you're ready to continue building out your workspace. [Create Your First Workflow](/docs/kizen-basics/kizen-in-action/create-your-first-workflow-or-kizen-in-action) to create an space.vars.object that goes through stages.
# Create Your First Workflow Object | Kizen Basics
Learn how to create a Workflow Object in Kizen to track operational processes through defined stages like Reported, Searching, and Resolved.
## Overview
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
The Reyes family has been enjoying their visit to space.vars.Theme\_park\_name. Later in the day, Elena realizes she left her backpack near one of the roller coaster rides. Marcus reports the lost item to guest services, and a staff member creates a **Lost Item Request** to track the search.
As park staff investigate, the request moves internally through several stages: **Reported**, **Searching**, **Located,** **Resolved,** and **Not Found**.
Processes like this are managed in space.vars.Kizen\_company\_name using a **Workflow Object**.
A Workflow space.vars.object tracks how work progresses through a structured process. Instead of Records simply storing information, they move through defined **stages** that represent milestones in the lifecycle of a task.
In this walkthrough, you’ll create a **Lost Item Requests Workflow Object** that allows space.vars.Theme\_park\_name staff to track lost items reported by park visitors.
You will:
* Create a new space.vars.object
* Enable the **Contains Workflow** setting
* Configure stages that represent the lost item process
This Workflow space.vars.object will allow space.vars.Theme\_park\_name staff to track operational requests and ensure the right team members take action at the right time.
### Why This Matters
Workflows transform space.vars.objects from **data containers** into **operational processes**.
Without workflows, space.vars.entities only store information. With workflows enabled, Records move through a structured lifecycle that teams can track and manage.
Clear workflow design helps prevent issues such as:
* Staff losing visibility into operational tasks
* Requests becoming stuck without clear ownership
* space.vars.automations triggering at the wrong time
* Reporting failing to reflect real operational progress
A well-designed Workflow ensures that work moves consistently through your organization and that teams always understand **what stage a task is in**.
### Before You Begin
Before creating a Workflow space.vars.object, make sure you have the following:
* **Admin or Technical Builder permissions**
* A **Business workspace created**
* Access to **Data** > **Custom Objects** in your navigation
Workflow space.vars.objects are best used when work follows a **repeatable lifecycle**, such as service requests, approvals, onboarding processes, or operational tasks.
***
## Create Your Workflow
{% stepper %}
{% step %}
#### Navigate to **Objects**
space.vars.objects page.
{% endstep %}
{% step %}
#### Select **NEW OBJECT**
{% hint style="info" %}
**Note:** Admins and technical builders with the correct permissions will see the full creation interface.
{% endhint %}
{% endstep %}
{% step %}
#### Fill out the **General Settings** page
space.vars.object and take you to the Stage Settings
{% endstep %}
{% step %}
#### Configure Stage Settings
This is where you define the lifecycle stages that each **Lost Item Request** will move through as staff investigate the missing item.
space.vars.automations rely on **stage changes**, which is why creating a workflow is an essential step in managing operational processes.
***
## Workflow Capabilities by Role
{% columns %}
{% column %}
#### Admins
* Create and manage Workflow space.vars.objects
* Define stages and lifecycle structures
* Configure permissions and access controls
* Design operational processes used across the organization
{% endcolumn %}
{% column %}
#### Technical Builders
* Integrate external systems that create or update workflow Records
* Trigger space.vars.automations when Records change stage
* Use APIs to manage workflow-enabled Objects programmatically
* Build scalable workflow pipelines that support operational space.vars.automations
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
The **Lost Item Request Workflow** at space.vars.Theme\_park\_name is just one example of how organizations use workflows to manage operational processes. The same structure appears across many industries.
{% tabs %}
{% tab title="Insurance" %}
In insurance, workflows are frequently used to manage the lifecycle of a claim. When a policyholder reports an incident, the claim must move through several stages as it is reviewed and processed by different teams.
A typical claim workflow might look like:
Claim Submitted → Investigation → Documentation Review → Approved → Closed
Each stage represents a specific step in the claims process.
For example:
* **Claim Submitted:** A policyholder reports an incident, such as a car accident or property damage. A claim record is created in the system.
* **Investigation:** Claims adjusters review the incident, assess damages, and determine coverage eligibility.
* **Documentation Review:** Supporting materials such as photos, estimates, and statements are collected and verified.
* **Approved:** The insurer confirms the claim is valid and authorizes payment.
* **Closed:** Payment is issued and the claim is finalized.
As the claim moves through these stages, the system can trigger automated actions such as assigning adjusters, requesting documentation, notifying customers of updates, or initiating payment processing.
Just like the Lost Item Request workflow tracks the progress of a search at space.vars.Theme\_park\_name, a Claims Workflow tracks the progress of an insurance investigation from the moment it is reported until it is resolved.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, workflows are frequently used to manage the lifecycle of a patient referral. When a provider refers a patient to a specialist, the request must move through several stages as it is reviewed, verified, and scheduled by different team members.
A typical referral workflow might look like:
Referral Received → Insurance Verified → Appointment Scheduled → Visit Completed → Follow-Up Sent
Each stage represents a specific step in the referral process.
For example:
* **Referral Received:** A provider submits a referral for a patient to see a specialist. A referral record is created in the system.
* **Insurance Verified:** The administrative team confirms the patient's coverage and obtains any necessary authorizations.
* **Appointment Scheduled:** The specialist's office confirms availability and books the patient's appointment.
* **Visit Completed:** The patient attends the appointment and the specialist submits their notes back to the referring provider.
* **Follow-Up Sent:** The care team reviews the outcome and sends any follow-up instructions or next steps to the patient.
As the referral moves through these stages, the system can trigger automated actions such as notifying the patient of their appointment, alerting staff when authorization is still pending, or sending follow-up communications once the visit is complete.
Just like the Lost Item Request workflow tracks the progress of a search at space.vars.Theme\_park\_name, a Referral Workflow tracks the progress of a patient referral from the moment it is submitted until care is complete.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, workflows are frequently used to manage the lifecycle of a loan application. When a customer applies for a loan, the request must move through several stages as it is reviewed, evaluated, and approved by different teams.
A typical loan workflow might look like:
Application Received → Document Review → Risk Evaluation → Approved → Account Opened
Each stage represents a specific step in the lending process.
For example:
* **Application Received:** A customer submits a loan application. A record is created in the system and assigned to a lending coordinator.
* **Document Review:** The team collects and verifies supporting materials such as income statements, tax returns, and identification.
* **Risk Evaluation:** Underwriters assess the applicant's credit history, debt-to-income ratio, and overall financial profile.
* **Approved:** The institution confirms the loan terms and the customer accepts the offer.
* **Account Opened:** Funds are disbursed and the loan account is activated.
As the application moves through these stages, the system can trigger automated actions such as requesting missing documents, notifying the applicant of their status, alerting compliance teams for review, or initiating fund disbursement once approval is confirmed.
Just like the Lost Item Request workflow tracks the progress of a search at space.vars.Theme\_park\_name, a Loan Application Workflow tracks the progress of a lending request from the moment it is submitted until funds are in the customer's hands.
{% endtab %}
{% endtabs %}
***
## What’s Next?
Now that your **Lost Item Requests** Workflow space.vars.object is created, you’re ready to begin adding real requests. In the next topic, [Modify Your Workflow](/docs/kizen-basics/kizen-in-action/move-through-your-workflow-or-kizen-basics) you’ll move the **Lost Item Request Record** for Sofia’s backpack through stages.
# Move Through Your Workflow | Kizen Basics
Learn how to update existing Records in Kizen and understand how changes impact Workflow Objects and Agentic Workflows.
To modify Records, you must:
* Be an **Admin** or **Technical Builder** with record edit permissions
* Have completed:
* **Create Your First Contact Record**
* **Create Your First Custom Object**
* **Create Your First Record**
You should already have:
* Three Guest Records: **Elena, Sofia, and Caleb**
* One Ticket Record linked to **Marcus**
## Overview
Earlier, Marcus reported Sofia’s missing backpack to guest services, and a staff member created a **Lost Item Request Record** to track the search. Because the **Lost Item Requests Object** is configured as a **Workflow Object**, the request does not remain static. Instead, it moves through stages as the investigation progresses:
Reported → Searching → Located → Resolved
or
Reported → Searching → Not Found
Each stage represents a step in the operational process. As park staff work on the request, they update the **stage** to reflect the current status. In this walkthrough, you’ll learn how to **move a Record through workflow stages**, allowing your team to track progress and triggerspace.vars.automations as work advances.
### Why This Matters
Workflow stages are what turn a Record into **a trackable operational process**.
Updating a Record’s stage allows teams to:
* Track progress in real time
* Trigger aspace.vars.automations when work advances
* Maintain visibility into operational tasks
* Generate accurate reports on workflow activity
Without updating stages, workflows cannot accurately reflect the status of work across your organization.
### Before You Begin
Before moving a Record through workflow stages, make sure you have the following:
* The **Lost Item Requests Workflow Object** has been created (see [Create Your First Workflow](https://d91da5062c56835d5b5956382d755d80.claudemcpcontent.com/mcp_apps?connect-src=https%3A%2F%2Fesm.sh+https%3A%2F%2Fcdnjs.cloudflare.com\&resource-src=https%3A%2F%2Fesm.sh+https%3A%2F%2Fcdnjs.cloudflare.com+https%3A%2F%2Fcdn.jsdelivr.net+https%3A%2F%2Funpkg.com+https%3A%2F%2Fassets.claude.ai\&dev=true#))
* Workflow stages configured
* A **Lost Item Request Record** already exists
If you have not created a Record yet, complete the steps in [Create Your First Record](/docs/kizen-basics/kizen-in-action/create-your-first-record-or-kizen-basics) before continuing.
***
## Move Through Your Workflow
{% stepper %}
{% step %}
#### Go to the Lost Item Request Workflow Object
1. In the top navigation, select **Data**.
2. Choose **Custom Objects**.
3. Select **Lost Item Request** under the Entity Name Column.
space.vars.automations.
For example:
* When a request moves to **Searching**:
* Staff are notified that a lost item investigation has begun
* A task can be assigned to the park operations team
* When a request moves to **Located**:
* Guest services can be prompted to contact the guest
* When a request moves to **Resolved**:
* A confirmation message can be sent
* The request can be archived
Because space.vars.automations respond to stage changes, updating workflow stages is essential for keeping operational processes moving.
***
## Workflow Capabilities by Role
{% columns %}
{% column %}
#### Admins
* Design workflow pipelines
* Configure stages and lifecycle structures
* Monitor workflow performance across teams
{% endcolumn %}
{% column %}
#### Technical Builders
* Update workflow stages using APIs
* Trigger space.vars.automations when Records move between stages
* Integrate external systems that create or update workflow Records
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
Moving Records through workflow stages is a common operational pattern across industries.
{% tabs %}
{% tab title="Insurance" %}
In insurance, workflows are frequently used to manage the lifecycle of a **claim**. When a policyholder reports an incident, the claim must move through several stages as it is reviewed and processed by different teams.
A typical claim workflow might look like:
Claim Submitted → Investigation → Approved → Closed
Each stage represents a specific step in the claims process.
For example:
* **Claim Submitted:** A policyholder reports an incident, such as a car accident or property damage. A claim record is created in the system.
* **Investigation:** Claims adjusters review documentation, assess damages, and determine coverage eligibility.
* **Approved:** The insurer confirms the claim is valid and authorizes payment.
* **Closed:** Payment is issued and the claim is finalized.
As the claim moves through these stages, the system can trigger automated actions such as assigning adjusters, requesting documentation, notifying customers of updates, or initiating payment processing.
Just like the **Lost Item Request** workflow tracks the progress of a search at Flywheel Adventure Park, a **Claims Workflow** tracks the progress of an insurance investigation from the moment it is reported until it is resolved.
{% endtab %}
{% tab title="Healthcare" %}
Healthcare organizations often rely on workflows to manage **patient visits and care coordination**.
For example, an appointment or care request may move through stages such as:
Appointment Requested → Scheduled → Checked In → Completed
Each stage reflects the patient’s progress through the healthcare process.
For example:
* **Appointment Requested:** A patient requests a visit through a patient portal or by calling the clinic.
* **Scheduled:** The appointment is confirmed and assigned to a provider.
* **Checked In:** The patient arrives at the clinic and begins the visit process.
* **Completed:** The visit is finished and medical notes are recorded.
As records move through these stages, the system can automatically send reminders, notify staff, update patient records, and trigger billing workflows.
Just as the Flywheel team updates the stage of a **Lost Item Request**, healthcare teams update appointment or care records to reflect the patient’s progress through the care process.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, workflows are commonly used to manage processes such as **loan applications, account openings, and compliance reviews**.
A loan application workflow might include stages such as:
Application Received → Document Review → Risk Evaluation → Approved
Each stage represents a step in evaluating the applicant and determining whether the loan can be issued.
For example:
* **Application Received:** A customer submits an application for a loan or credit product.
* **Document Review:** Staff verify financial documents, identification, and supporting information.
* **Risk Evaluation:** Underwriters assess credit risk and determine eligibility.
* **Approved:** The loan is approved and the account is created.
As the record progresses through these stages, the system may automatically request documents, notify reviewers, update risk assessments, and prepare final agreements.
Just as Flywheel staff move the **Lost Item Request** through stages while investigating the backpack, financial institutions move **loan or account records** through structured workflows to ensure each step of the process is completed correctly.
{% endtab %}
{% endtabs %}
***
## What’s Next?
Now that you know how to move Records through workflow stages, the next step is to **automate these processes**.
In the next topic, **Create Your First Agentic Workflow**, you’ll learn how stage changes can trigger actions such as:
* Sending notifications
* Assigning tasks
* Updating related Records
This allows your workflows to not only track progress, but also **coordinate work automatically across your organization.**
***
# Update A Contact Record | Kizen Basics
Learn how to modify a Contact Record by adding Custom Fields so you can connect guest Activity to operational events and power timely Agentic Workflows.
## Overview
While guest services helps Marcus recover Sofia’s backpack, the staff member reviewing the request noticed something missing from the space.vars.contact space.vars.entity.
The **Lost Item Request** is linked to Marcus’s space.vars.contact space.vars.entity, but the **visit date** for the Reyes family is missing. Without that information, staff cannot easily confirm when the family entered the park or trigger future space.vars.automations tied to guest visits.
To correct this, the staff member updates Marcus’s space.vars.contact space.vars.entity to include the **Visit Date**.
### Why This Step Matters
Capturing the **Visit Date** allows Flywheel Adventure Park to connect operational events, such as lost item requests, to the guest’s actual park visit.
This information will also be used in other tutorials when creating space.vars.automations that respond to guest activity.
For example, space.vars.automations could:
* Send reminders before a guest’s visit
* Assign operational tasks to park staff
* Send follow-up messages after a visit
Accurate record data ensures that these space.vars.automations run at the correct time.
### Before You Begin
Before updating Marcus’s space.vars.contact space.vars.entity, make sure you have:
* Permission to edit space.vars.contacts and create space.vars.fields
* Access to **Data** > **Contacts**
* A space.vars.contact space.vars.entity for Marcus already created (see [Create Your First Record](/docs/kizen-basics/kizen-in-action/create-your-first-record-or-kizen-basics))
***
## Update a Contact Record
{% stepper %}
{% step %}
#### Open the Contact Columns Editor
1. Navigate from **Data** > **Contacts**.
2. Locate the **Edit Columns** icon on the right side of the table header and select **Edit Columns**.
space.vars.contact space.vars.object.
{% endstep %}
{% step %}
#### Add the Field to the Contact Table
After creating the field, it must be added to the visible table columns. After adding **Visit Date** field, you'll land on the **Custom Fields** space.vars.contact Settings page.
space.vars.automation that moves requests through stages. For example, when a request moves from **Reported** to **Searching**, an space.vars.automation could assign the task to the appropriate team or notify staff responsible for the ride area where the item may have been lost.
Learn how to create this process in [Create Your First Agentic Workflow](/docs/kizen-basics/kizen-in-action/create-your-first-agentic-workflow-or-kizen-basics) topic.
# Create Your First Agentic Workflow | Kizen Basics
Learn how to create Agentic Workflows in Kizen to send emails, trigger actions, and automate workflows using Contact Records and scheduled triggers.
## Overview
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
In space.vars.Kizen\_company\_name, an space.vars.automation allows the platform to perform actions automatically when specific conditions are met. space.vars.automations connect your space.vars.entities, space.vars.activities, and communications, ensuring important tasks happen without manual effort.
In this walkthrough, you’ll create your first space.vars.automation using the Reyes family example. Because birthdays are stored in space.vars.contact space.vars.entities, space.vars.Theme\_park\_name can automatically send guests a Birthday Celebration email when their birthday occurs.
In this lesson, you will create an space.vars.automation that checks space.vars.contact birthdays and sends a birthday email automatically.
### Why This Matters
space.vars.automations help businesses reduce manual work while ensuring important processes run consistently.
Using space.vars.automations allows you to:
* Automatically send communications to customers
* Trigger tasks or follow-up actions based on data changes
* Maintain consistent customer engagement
* Ensure important processes run without human intervention
For example, the birthday message space.vars.automation ensures that every guest receives a personalized message without requiring staff to manually review space.vars.contact space.vars.entities. As your system grows, space.vars.automations help your organization operate more efficiently by connecting data, space.vars.workflows, and communications.
### Before You Begin
To complete this lesson, you must:
* Be an **Admin or Technical Builder** with permission to create space.vars.automations
* Have completed the previous lessons:
* [Create Your First Contact Record](/docs/kizen-basics/kizen-in-action/create-your-first-contact-record-or-kizen-basics)
* [Create Your First Object](/docs/kizen-basics/kizen-in-action/create-your-first-object-or-kizen-basics)
* [Create Your First Record](/docs/kizen-basics/kizen-in-action/create-your-first-record-or-kizen-basics)
You should also have:
* space.vars.contact space.vars.entities created for **Marcus, Elena, Sofia, and Caleb Reyes**
* Birthday fields populated in each space.vars.contact space.vars.entity
In this section, you will create an space.vars.automation that sends a birthday email when a space.vars.contact’s birthday matches the current date.
This space.vars.automation uses three core components:
* [**Trigger**](/docs/concepts/agentic-workflows/agentic-workflow-triggers)**:** The event that starts the space.vars.automation. In this example, the trigger occurs when a space.vars.contact's birthday matches the current day.
* **Condition (Topic Coming Soon):** Optional rules that branch execution based on criteria you define. In this example, a condition checks whether the space.vars.contact's email field is not blank before proceeding to send the email.
* **Action (Topic Coming Soon):** The task performed by the space.vars.automation. In this lesson, the action sends a **Birthday Celebration email**.
If you would like to learn more about how space.vars.automations work, see [Agentic Workflows](/docs/concepts/agentic-workflows).
***
## Create Your First Automation
{% stepper %}
{% step %}
#### Navigate to Agentic Workflows
From the main navigation menu, select **Agentic Workflow**
space.vars.automation management page where you can view, edit, and create automated space.vars.workflows and folders.
{% endstep %}
{% step %}
#### Create a New Agentic Workflow
Select **NEW AGENTIC WORKFLOW**
space.vars.entity-based
{% hint style="info" %}
**Note:** We selected **Record-based** because this space.vars.automation needs to evaluate and react to data on individual space.vars.contact space.vars.entities.
{% endhint %}
space.vars.entity-based vs Global space.vars.automationsspace.vars.automation, you can choose between two types: **Record-based** and **Global.**
* **Record-based Automations** run when something happens to a specific space.vars.entity in your data, such as a space.vars.contact, Ticket, or other space.vars.object. A common example, sending a confirmation email when a ticket purchase is created.
* **Global Automations** run independently of a specific space.vars.entity. These are typically used for scheduled processes or external triggers, such as checking for birthdays each day or responding to a webhook from another system.
For more information, see Automations **(Coming Soon)**.
space.vars.automation creator. However, this field allows you to also add additional recipients, such as a team email or distribution list.
{% endhint %}
* **Folder:** *(Blank)*
{% hint style="info" %}
**Note:** If left blank, the space.vars.automation will be created in the **Root Folder**. You can also enter a folder name here to create a new folder and organize the **Agentic Workflow** within it.
{% endhint %}
space.vars.automation. To do this, first select **Click to add new trigger.**
space.vars.contacts on their birthday, offering a special discount and encouraging guests to visit space.vars.Theme\_park\_name again.
* **Choose Date Field:** Birthday
* **Time Offset:** Day(s) before, 2, at 7:00 AM
* **Allow Trigger to Activate Every Year:** Enabled
space.vars.automation runs each day, it checks the **Birthday field** in space.vars.contact space.vars.entities and sends an email **two days before the guest’s birthday**.
Select **SAVE**
space.vars.automation. Variables become useful when you need to capture and reuse data across multiple steps in more complex space.vars.workflows. To learn more, see Agentic Workflow Variables. **(Topic Coming Soon)**
{% endhint %}
space.vars.automation should do when the trigger condition is met. To do this, select the **+** on the **Yes** condition and **Add Action.**
space.vars.contact when the space.vars.automation detects that their birthday has occurred.
* **CC Team Members:** None
* **Choose Email To Send:** Create a New Email Template
{% hint style="info" %}
**Note:** This will open the **Email Builder** in space.vars.Kizen\_company\_name. For this walkthrough, you do not need to modify the email design. Simply enter **“Happy Birthday Email”** in the Subject Line field, then select **Save & Close**.
{% endhint %}
* **Error Handling:** Continue and Notify on Failure
space.vars.automation configuration to ensure it is correct, then activate the space.vars.automation by turning on the **Active?** toggle.
space.vars.automation is now live.
Each day, the system will check your space.vars.contact space.vars.entities and automatically send birthday emails to any guests celebrating two days before.
***
## Apply What You've Learned
Now that you understand how space.vars.automations work, you will create a second space.vars.automation using the Reyes family example.
As you know, Marcus recently purchased tickets for his family to visit space.vars.Theme\_park\_name. To help guests prepare for their visit, the park sends a reminder email the day before the scheduled trip. This message includes helpful information such as park hours, parking details, and what guests should bring for the day.
In this exercise, you will create an space.vars.automation that sends Marcus a reminder email one day before his park visit.
#### Your Task
Create a New space.vars.automation with the following:
* **Automation Name:** Visit Reminder Email
* **Automation Type:** space.vars.entity-based
* **Automation Object:** space.vars.contacts
* **Additional Error Notification Email:** *Blank*
* **Folder:** *Blank*
* **Trigger Type:** On or Around Date
* **Description:** Triggers when a Ticket space.vars.entity’s Visit Date is one day away, sending a reminder email to help guests prepare for their park visit.
* **Choose Date Field:** Visit Date
* **Time Offset:** Day(s) Before 1 at 10:00 AM
* **Allow Trigger to Activate Every Year:** Disabled
* **Action:** Send Email
* **Action Description:** Sends a reminder email to the guest one day before their scheduled park visit.
* **CC Team Members:** None
* **Choose Email To Send:** Create New email
{% hint style="info" %}
**Note:** This will open the **Email Builder** in space.vars.Kizen\_company\_name. For this walkthrough, you do not need to modify the email design. Simply enter **“Reminder Email”** in the Subject Line field, then select **SAVE & CLOSE**.
{% endhint %}
* **Error Handling:** Continue and Notify on Failure
Ensure that you enable your space.vars.automation and select **SAVE**.
space.vars.automations allow the system to respond automatically when important events occur.
In the space.vars.Theme\_park\_name example, space.vars.automations can be used to:
* Send birthday messages to guests
* Send reminders before park visits
* Notify staff when ride waivers are submitted
* Send follow-up surveys after park visits
But as your organization grows, space.vars.automations help ensure more complex processes run consistently and without manual effort, such as:
* Updating a guest's loyalty tier when their visit count reaches a threshold
* Creating a follow-up task and assigning it to the operations team when a waiver is flagged for review
* Moving a group booking space.vars.entity to a new stage when a deposit payment is received
* Triggering a maintenance inspection space.vars.entity when a ride logs a specified number of cycles
* Updating seasonal pass status fields when an expiration date passes
To continue learning about all of the space.vars.automation functionality, see [Agentic Workflows](/docs/concepts/agentic-workflows).
***
## Agentic Workflow Capabilities by Role
{% columns %}
{% column %}
#### Admins
* Create and manage space.vars.automations
* Configure triggers and conditions
* Define automated actions
* Monitor space.vars.automation space.vars.activity and performance
{% endcolumn %}
{% column %}
#### Technical Builders
* Create space.vars.automations using API triggers
* Connect space.vars.automations to external systems
* Trigger space.vars.automations through webhooks
* Integrate space.vars.automations into larger space.vars.workflows
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
The space.vars.automations you created for the Reyes family are specific to space.vars.Theme\_park\_name, but the same concepts apply across many industries. space.vars.automations connect your data, processes, and communications, ensuring important actions occur automatically when specific conditions are met.
Below are examples of how space.vars.automations similar to the ones in this walkthrough are used in Insurance, Healthcare, and Financial Services.
{% tabs %}
{% tab title="Insurance" %}
In insurance, space.vars.automations connect policy, claims, and customer data with operational processes that support underwriting and policy servicing.
Common Automations include:
* Routing new claims to the appropriate adjuster based on claim type and region
* Moving a policy space.vars.entity to a pending review stage when an application is submitted
* Creating a document request space.vars.entity when required policy information is missing
* Updating a policy status field automatically when a renewal deadline passes
Just like space.vars.Theme\_park\_name automates operational processes to keep things running smoothly, insurers use space.vars.automations to move work through underwriting and policy servicing without manual handoffs.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, space.vars.automations help manage patient space.vars.entities, care coordination, and operational workflows.
Common Automations include:
* Assigning a care coordinator to a patient space.vars.entity when an intake form is completed
* Moving a patient space.vars.entity to a new care stage after a visit is logged
* Creating a follow-up task when a referral is submitted
* Updating a patient's status field when lab results are received
Just like space.vars.Theme\_park\_name uses space.vars.automations to keep guest and operational space.vars.entities current, healthcare organizations use space.vars.automations to ensure patient space.vars.entities reflect the right state at every stage of care.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, space.vars.automations support account management, compliance, and client space.vars.workflow coordination.
Common Automations include:
* Routing loan applications to the appropriate review team based on loan type
* Updating an application status field when document verification is completed
* Creating a compliance task space.vars.entity when a required disclosure threshold is reached
* Assigning an advisor to a new account space.vars.entity when an investment request is submitted
Just as space.vars.Theme\_park\_name uses space.vars.automations to manage guest space.vars.entities and operational processes, financial institutions use space.vars.automations to move work through review, approval, and compliance space.vars.workflows reliably and at scale.
{% endtab %}
{% endtabs %}
***
## What’s Next
Now that you’ve created your first space.vars.automations, the next step is learning about [Scheduling Activities and Timeline](/docs/kizen-basics/kizen-in-action/scheduling-your-activity-and-timelines-or-kizen-in-action). In the next topic, you’ll learn how to Schedule space.vars.activities and track interactions directly on space.vars.entities using the space.vars.timeline.
# Create Your First Activity | Kizen Basics
Create your first Kizen Activity using a Purchase Tickets example. Define Activity settings, notifications, and calendar integration for your team.
## Overview
{% hint style="warning" %}
**Caution**: This setup reflects space.vars.Kizen\_company\_name's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
Flywheel Adventure Park runs on recurring guest interactions: ticket purchases, waiver confirmations, gate check-ins, lost item reports, and concession sales. Staff need a consistent way to capture what happened, when, and who was involved.
space.vars.activities are how space.vars.Kizen\_company\_name structures those interactions. Before your team can log or schedule anything, an administrator must create the space.vars.activity by defining its name, what it tracks, and how it connects to your workspace.
In this guide, you will create a **Purchase Tickets** space.vars.activity, which staff will use to track ticket purchases like the one made by the Reyes family.
Once created, the space.vars.activity is available across space.vars.Kizen\_company\_name. Staff can schedule it ahead of a visit or log it on the spot, connecting it to space.vars.contact space.vars.entities, Tickets, and other space.vars.entities to power the space.vars.timeline, reporting, and downstream space.vars.automations.
### Why This Matters
space.vars.activities are the building blocks of how work gets tracked in space.vars.Kizen\_company\_name. Without a defined space.vars.activity type, there's no consistent way for staff to space.vars.entity that tickets were purchased, a waiver was confirmed, or a lost item was returned. Every team member would log these moments differently, and reporting would become unreliable.
By creating space.vars.activities thoughtfully, space.vars.Theme\_park\_name ensures that:
* Staff have a shared vocabulary for the work they do every day
* Each interaction is captured in a structured, searchable way
* Timelines give a complete picture of every guest's journey
* space.vars.workflows and space.vars.automations can trigger off real, consistent data
* Reports accurately reflect what's happening across the park
Creating your first space.vars.activity establishes the foundation that scheduling, logging, and space.vars.automation all depend on.
***
## Before You Begin
Before creating an space.vars.activity, make sure the following are in place:
* You have administrator permissions to create and configure space.vars.activities
* Your business workspace has been created and your business settings configured
* The space.vars.objects this space.vars.activity will associate with (such as Tickets and Contacts) have been created
* You've identified the team members who will schedule and log this space.vars.activity
* You understand the type of interaction this space.vars.activity should capture
Having these items ready ensures your space.vars.activity can be created and immediately connected to the rest of your workspace.
***
## Creating an Activity
{% stepper %}
{% step %}
#### Navigate to **Activities**
From the top navigation, select **Platform > Activities**.
The space.vars.activities page appears, showing any space.vars.activities that already exist in your workspace.
{% endstep %}
{% step %}
#### Create a **New Activity**
On the space.vars.activities page, select **NEW ACTIVITY** in the upper-right corner.
space.vars.activity.
The space.vars.activity Settings page appears, where you'll configure the details.
{% endstep %}
{% step %}
#### Confirm Your Activity Settings
At the top of the space.vars.activity Settings page, you'll see six tabs: **Activity Settings**, **Build**, **Team Sharing Settings**, **Advanced Rules**, **Scheduled/Logged**, and **Timeline**.
You'll start on the **Activity Settings** tab. Here, confirm the space.vars.activity name reads **Purchase Tickets**. The **API Name** field auto-fills as `purchase_tickets` and is used when referencing this space.vars.activity through integrations or the API.
space.vars.activity when they encounter it later in space.vars.workflows, space.vars.automations, or reports.
{% endstep %}
{% step %}
#### Configure Your Activity
**1. Set the Default Submission Action**
* Under **Default Submission Action**, leave the dropdown set to **None**.
**2. Configure Notifications**
* In the **Notifications** panel, you can notify team members by email or text each time this space.vars.activity is logged.
* For this first space.vars.activity, leave both **Notify Team Members via Email** and **Notify Team Members via Text** empty. You'll handle per-scheduled-space.vars.activity notifications (such as reminders to Marcus Reyes) when scheduling individual instances of this space.vars.activity.
**3. Configure Calendar Integration**
* In the **Calendar Integration** panel, leave **Create Events for Scheduled Activities** toggled off.
* When enabled, this setting sends a calendar invitation to the assigned team member whenever this space.vars.activity is scheduled. You can turn this on later if your team wants scheduled space.vars.activities to appear on their connected calendars.
**4. Save Your Activity**
* Your space.vars.activity is saved automatically as you configure it. You can now navigate back to the space.vars.activities page using **BACK TO ACTIVITIES** in the upper-left.
{% endstep %}
{% step %}
### Save Your Activity
Your space.vars.activity is saved automatically as you configure it. You can now navigate back to the space.vars.activities page using **BACK TO ACTIVITIES** in the upper-left.
{% endstep %}
{% endstepper %}
The Purchase Tickets space.vars.activity now appears in your space.vars.activities list and is available across the workspace for scheduling and logging.
***
## Apply What You've Learned
Now that you've created one space.vars.activity, apply what you've learned. Create a second space.vars.activity using the same steps. This time, create a **Ride Waiver Submissions** space.vars.activity that Guest Services will use to track waiver completion for families visiting the park.
Use the information below to set it up.
**Activity Settings**
* **Activity Name**: *Ride Waiver Submissions*
* **API Name**: `ride_waiver_submissions` (auto-fills)
* **Activity Description**: Tracking Ride Waiver Submissions
* **Default Submission** Action: None
**Notifications**
* Notify Team Members via Email: Leave blank
* Notify Team Members via Text: Leave blank
**Calendar Integration**
* Create Events for Scheduled space.vars.activities: Off
When you've finished, both **Purchase Tickets** and **Ride Waiver Submissions** should appear in your space.vars.activities list, ready to be scheduled or logged.
***
## How This Fits Into Agentic Workflows
space.vars.activities are the raw material thar space.vars.automations act on. Once an space.vars.activity exists, it becomes available as a trigger, an action, and a data point across the platform.
In the space.vars.Theme\_park\_name example, the Purchase Tickets space.vars.activity you just created can be used to:
* Trigger an space.vars.automation that sends a purchase confirmation email to Marcus Reyes when tickets are logged for Sofia and Caleb
* Advance a guest-preparation space.vars.workflow once tickets are purchased, prompting the scheduling of Ride Waiver Confirmations
* Feed logged purchases into a sales dashboard showing daily ticket revenue and attendance projections
* Kick off a follow-up task for staff when a purchase includes add-ons that require additional setup
* Populate the space.vars.timeline on Marcus's space.vars.contact space.vars.entity so any staff member can see his purchase history at a glance
Creating the space.vars.activity is step one. Scheduling and logging it, and then connecting it to space.vars.workflows and space.vars.automations, is where operational value compounds.
***
## Create Activity Capabilities by Role
{% columns %}
{% column %}
### Admins
* Create new space.vars.activity types and configure their settings
* Define space.vars.activity descriptions, API names, and default submission actions
* Configure logging notifications and calendar integration
* Manage team sharing settings and advanced rules for each space.vars.activity
* Archive or delete space.vars.activities that are no longer in use
{% endcolumn %}
{% column %}
### Technical Builders
* Reference space.vars.activities by API name in integrations and custom code
* Trigger space.vars.automations based on space.vars.activity scheduling or logging
* Build custom fields and forms on the Build tab to capture space.vars.activity-specific data
* Configure advanced rules to enforce required fields or conditional logic
* Connect logged space.vars.activity data to external systems and reporting tools
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
At space.vars.Theme\_park\_name, creating a Purchase Tickets space.vars.activity establishes a consistent way to capture a recurring guest transaction. The same pattern, which involves defining a structured interaction type before tracking individual instances, applies across industries where repeatable transactions or touch points need to be captured reliably.
{% tabs %}
{% tab title="Insurance" %}
Creating a Purchase Tickets space.vars.activity is similar to defining standard transactional Activities in insurance.
For example:
* A Policy Purchase space.vars.activity used every time a new policy is bound
* A Premium Payment space.vars.activity used whenever a payment is received
* A Coverage Add-On space.vars.activity used when a rider is added to an existing policy
Just as space.vars.Theme\_park\_name standardizes how ticket purchases are tracked, insurance teams standardize how policy transactions are recorded.
{% endtab %}
{% tab title="Healthcare" %}
In healthcare, a defined space.vars.activity corresponds to a standard patient-encounter type.
For example:
* An Appointment Scheduled space.vars.activity used when a visit is booked
* A Co-Pay Collection space.vars.activity used at check-in
* A Prescription Fulfilled space.vars.activity used when medication is dispensed
These Activities ensure every patient transaction is captured the same way, regardless of which staff member handles it.
{% endtab %}
{% tab title="Financial Services" %}
In financial services, space.vars.activities map to recurring client transactions and service events.
For example:
* A New Account Opened space.vars.activity used during onboarding
* A Deposit Received space.vars.activity used for incoming funds
* A Trade Executed space.vars.activity used when an order is filled
Standardizing these space.vars.activities makes client service consistent and auditable, no matter who performs the work.
{% endtab %}
{% endtabs %}
***
## What's Next?
Next, you'll learn how to [Schedule an Activity](/docs/kizen-basics/kizen-in-action/scheduling-your-activity-and-timelines-or-kizen-in-action), using the space.vars.activities you just created, to plan interactions ahead of time, assign them to team members, and connect them to space.vars.contacts, Tickets, and other space.vars.entities across your workspace.
# Schedule Your Activity | Kizen Basics
Learn how to schedule Activities in Kizen and use timelines to plan and track future actions.
## **Overview**
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
A day at space.vars.Theme\_park\_name is full of interactions—families calling to confirm arrival times, guests checking in at the gate, safety briefings before rides, and follow-up messages after their visit. For the Reyes family, this includes confirming Sofia and Caleb’s ride waivers and making sure Marcus receives the right reminders before they arrive.
Some interactions happen *in the moment* and need to be **logged**. Others must be planned ahead of time and need to be **scheduled** to ensure the day runs smoothly.
You should create a Scheduled space.vars.activity when an interaction hasn’t happened yet, such as confirming ride waivers before a visit. When Marcus Reyes purchased tickets for his children, Sofia and Caleb, space.vars.Theme\_park\_name schedules a **Ride Waiver Confirmation** space.vars.activity. This ensures Guest Services can verify waiver completion and prepare wristbands ahead of time, allowing the kids to head straight to the rides upon arrival.
A Scheduled space.vars.activity like this typically includes details such as:
* **Type:** Ride Waiver Confirmation
* **Date & Time:** Morning of the visit
* **Assigned To:** Guest Services staff member Jacob Mulligan
* **Notes:** “Confirm both children’s waivers. Prepare wristbands to speed up ride access. Link to ticket records.”
* **Contacts:** Sofia and Caleb Reyes
### **Why This Matters**
Keeping space.vars.activities up to date ensures that space.vars.Theme\_park\_name staff always know:
* What happened
* What’s planned
* Who handled each touchpoint
* Whether follow-ups are still pending
When space.vars.activities are logged and scheduled correctly, the guest experience feels seamless, even on the busiest weekends. This guide walks through how to schedule an space.vars.activity using the Reyes family’s visit as a simple, day-in-the-life example.
### Before You Begin
Before scheduling an space.vars.activity, make sure the following are in place:
* The Contact record exists for Marcus Reyes
* Sofia Reyes Ride Waiver and Caleb Reyes Ride Waiver space.vars.entities have been created
* The space.vars.activity type you plan to schedule (such as Ride Waiver Confirmation) is available
* The assigned team member exists in space.vars.Kizen\_company\_name and has the appropriate permissions
* You have permission to schedule space.vars.activities and send notifications
Having these items ready ensures space.vars.activities can be scheduled, assigned, and connected correctly to space.vars.timelines and space.vars.workflows.
***
## Scheduling an Activity
{% stepper %}
{% step %}
#### Navigate to **Contacts**
From the top navigation, select **Data** > **Contacts**.
space.vars.activity.
{% endstep %}
{% step %}
#### Schedule an space.vars.activity on your Contact Record
On the Action panel in Marcus's space.vars.contact space.vars.entity select **SCHEDULE ACTIVITY**.
space.vars.activity modal appears.
{% endstep %}
{% step %}
#### Choose the Activity and fill out the fields
On the Schedule space.vars.activities modal, you can choose your space.vars.activity and fill out various fields.
Select **Ride Waiver Confirmation** from the Choose space.vars.activity dropdown (the topmost field).
space.vars.activity to the team member. Under **Assign Team Member**, be sure to choose via a dropdown Jacob Mulligan, your trusty guest service staffer.
{% hint style="info" %}
**Note**: Jacob Mulligan should be created for this step. If you don't see him, please read our [Configure Your Business](/docs/kizen-basics/kizen-in-action/configure-your-business-settings-or-kizen-basics) page.
{% endhint %}
{% endstep %}
{% step %}
#### Set Date and Time
* **Due Date:** Day of the visit (for our purposes, set it to two days ahead of the present date).
* **Time:** Morning (use 9:00 AM)
* **Why?** This ensures staff prepare waivers and wristbands before the family arrives.
{% endstep %}
{% step %}
#### Add a Note
Add a note regarding the current Scheduled space.vars.activity: “Confirm both children’s waivers. Prepare wristbands to speed up ride access. Link to ticket space.vars.entities.”
{% endstep %}
{% step %}
#### Set your Associations
Set associations for this Scheduled space.vars.activity.
* **Contacts** Contacts field is the person who needs to fill out this ride waiver (in this case, Marcus Reyes)
* **Concession:** *Blank*
* **Lost Item Requests:** *Blank*
* **Ride Waivers:** Sofia Reyes Ride Waiver
* **Tickets field:** This is connecting the waiver to a specific ticket (in this case, Marcus's purchase of Sofia's ticket). In the Tickets dropdown, select **Marcus Reyes - Flywheel Ticket**.
space.vars.Theme\_park\_name. So you're going to create two notifications
* You can choose whether or not to send a text or an email. For our purposes, leave it as an email.
* In the dropdown where you see **Minute(s)**, change it to **Days(s)**. These indicate the timelines before the Activity is due. We want to give Marcus some time to sign the waivers!
* Set the first notification to **1 Day** and the second to **4 hours**.
{% endstep %}
{% step %}
#### Select **SCHEDULE** to save
{% endstep %}
{% endstepper %}
Now you should see that the scheduled waiver confirmation appears on Marcus’s space.vars.timeline with the selected date and time, assigned staff member, activity details, related space.vars.entities, and any notes.
space.vars.activity, apply what you’ve learned. Schedule another space.vars.activity using the same steps and the Ride Waiver space.vars.object. This time, create the space.vars.activity for **Caleb’s waiver** instead of Sofia’s.
Use the information below to set it up.
**Activity Settings**
* **Activity:** Ride Waiver Submissions
* **Assignment Type:** Team Member
* **Assign Team Member:** Jacob Mulligan
* **Due Date:** Two days from today (visit date)
* **Time:** 9:00 AM
* **Notes:** Confirm both children’s waivers. Prepare wristbands to speed up ride access. Link to ticket space.vars.entities.
**Associations**
* **Contacts:** Marcus Reyes
* **Concession:** *Blank*
* **Lost Item Requests:** Leave blank
* **Ride Waivers:** Caleb Reyes Wide Waiver
* **Tickets:** Marcus Reyes - Flywheel Ticket
**Notifications**
Create two notifications:
* **Notification 1:** Send email **1 day before** activity is due
* **Notification 2:** Send email **4 hours before** activity is due
When you've finished, this should be present on Marcus Reyes's space.vars.timeline:
space.vars.activities represent planned touch points and are central to proactive space.vars.automations in space.vars.Kizen\_company\_name. In the Reyes family example, scheduling Ride Waiver Confirmation space.vars.activities ensures required steps happen before the family arrives. Once scheduled, these space.vars.activities can trigger reminders, assign tasks to staff, and prepare systems for the visit—helping teams address needs in advance rather than at check-in.
Scheduled space.vars.activities can be used to:
* Send reminders or notifications before a visit
* Assign preparation tasks based on timing or ticket type
* Ensure required steps, like waiver completion, aren’t missed
* Feed planning data into staffing and operational reports
By Scheduling space.vars.activities consistently, teams move from reactive to proactive. Guests receive timely communication, staff know what’s coming, and space.vars.automations handle preparation ahead of time. When the work is completed and logged, the space.vars.timeline closes the loop between planning and execution.
***
## Scheduling Activities Capabilities By Role
{% columns %}
{% column %}
#### Admins
* Create and manage space.vars.activity types used for scheduling
* Configure required fields, defaults, and associations
* Control permissions for scheduling space.vars.activities and sending notifications
* Define standard scheduling patterns for common space.vars.workflows
* Ensure scheduled space.vars.activities appear correctly on space.vars.timelines and reports
{% endcolumn %}
{% column %}
#### Technical Builders
* Automatically schedule space.vars.activities based on triggers or conditions
* Integrate space.vars.activity scheduling into space.vars.automations
* Schedule space.vars.activities programmatically using the API
* Configure notifications and follow-up actions
* Connect scheduled space.vars.activities to downstream systems and reporting
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
In the space.vars.Theme\_park\_name example, scheduling a Ride Waiver Confirmation ensures required steps are completed before the family arrives. The same scheduling pattern applies across industries where preparation, compliance, or follow-up must happen before a key event.
{% tabs %}
{% tab title="Insurance" %}
Scheduling a Ride Waiver Confirmation is similar to scheduling policy-related follow-ups in insurance.
For example:
* A policy renewal reminder scheduled before expiration
* A document collection task scheduled after a quote is issued
* A compliance review scheduled before coverage becomes active
Just as Guest Services prepares wristbands ahead of time, insurance teams prepare documentation and approvals before a policy milestone.
{% endtab %}
{% tab title="Healthcare" %}
At space.vars.Theme\_park\_name, waiver confirmation happens before the visit. In healthcare, Scheduled space.vars.activities support patient readiness before appointments or procedures.
For example:
* Appointment reminders scheduled before a visit
* Insurance verification tasks scheduled ahead of check-in
* Pre-procedure instructions scheduled for patients
In both cases, scheduling ensures staff and patients are prepared before arrival.
{% endtab %}
{% tab title="Financial Services" %}
The Ride Waiver Confirmation space.vars.activity parallels scheduled client touchpoints in financial services.
For example:
* Annual review meetings scheduled in advance
* Follow-up tasks scheduled after account changes
* Compliance check-ins scheduled around key financial events
Just as space.vars.Theme\_park\_name schedules preparation before a visit, financial teams schedule space.vars.activities to ensure readiness before client decisions or regulatory deadlines.
{% endtab %}
{% endtabs %}
***
## **What’s Next?**
Next, you’ll learn about [Logging your Activities](/docs/kizen-basics/kizen-in-action/tracking-your-activity-in-timelines-or-kizen-in-action), including how space.vars.activity space.vars.entities appear, update, and stay connected to your data.
# Log Your Activity | Kizen Basics
Learn how to log Activities in Kizen and use timelines to record and track completed actions.
## **Overview**
{% hint style="warning" %}
**Caution:** This setup reflects Kizen's default configuration. Your administrator may have customized your layout, so columns or navigation may appear differently. Trial accounts may have limited features.
{% endhint %}
When an interaction has already happened, log it as an space.vars.activity. Logged space.vars.activities capture real interactions—such as purchases, conversations, or questions—and place them on the space.vars.timeline so teams can see what happened and when.
During their visit, Marcus stops at the snack stand to buy fried dough for his kids. While ordering, he chats with a staff member and asks whether the fried dough contains nuts, since his son Caleb has a nut allergy.
This interaction should be logged as an space.vars.activity. Logging it records where the family stopped, what they purchased, and important context like allergy concerns. Over time, these entries create a shared, accurate view of the guest experience across teams.
### Why This Matters
Small interactions often carry important context. In the Reyes family’s visit, a simple snack purchase also included a question about nut allergies. When that interaction is logged, it becomes more than just a transaction.
Logged Activities help teams:
* See purchases alongside guest questions or concerns
* Anticipate needs before issues arise, such as allergies or accessibility requests
* Maintain continuity as guests interact with different staff members or departments
* Turn everyday moments into data that supports reporting, staffing, and operational decisions
Without logged space.vars.activities, these details exist only in the moment. By capturing them on the space.vars.timeline, space.vars.Kizen\_company\_name helps teams understand, share, and improve the guest experience across the entire operation.
### Before You Begin
Before logging space.vars.activities, make sure the following are in place:
* You’ve completed [Scheduling Your Activities & Timelines](/docs/kizen-basics/kizen-in-action/scheduling-your-activity-and-timelines-or-kizen-in-action)
* The **Reyes family Contacts and Guests** have already been created
* An space.vars.activity exists for **Concessions Purchase**
* A **Concession** space.vars.object exists
* You have permission to log space.vars.activities on space.vars.contact space.vars.entities
If these items are set up, you’re ready to begin logging real guest interactions.
***
## Logging An Activity
{% stepper %}
{% step %}
#### Go to a Contact Record and select LOG ACTIVITY
Assuming you're still on Marcus Reyes's space.vars.contact page, go to the Notes panel. From there, select **LOG ACTIVITY**. The dropdown will give you various space.vars.activities to use. Select **Concessions Purchase**.
space.vars.activity's panel you can see various fields.
space.vars.activity appear on Marcus’s space.vars.timeline with the selected date and time, assigned staff member, space.vars.activity details, related space.vars.entities, and any notes.
It will look like this:
space.vars.activity, apply what you’ve learned. Log another space.vars.activity using the same steps. This time, log the space.vars.activity of Marcus buying a soda for his wife Elena.
You can complete **Concession Purchases Activity** using the details below:
**Verify Associations**
* **Contacts:** Marcus Reyes
* **Concessions:** Soda
* **Lost Item Requests:** Leave blank
* **Ride Waivers:** Leave blank
* **Tickets:** Marcus Reyes - Flywheel Ticket
**Complete Activity**
* **Notes:** Marcus purchases a soda for his wife Elena.
When you're finished, your logged space.vars.activity should appear on the space.vars.timeline like this:
space.vars.activities do more than space.vars.entity history. They become triggers and data inputs for space.vars.workflows and space.vars.automations across space.vars.Kizen\_company\_name.
In the Reyes family example, logging a fried dough purchase can automatically initiate follow-up actions, such as updating inventory levels, flagging allergy-related notes, or contributing to concession sales reports. Because each space.vars.activity is connected to space.vars.contacts, Tickets, and staff members, space.vars.workflows can respond to real interactions as they happen.
When space.vars.activities are logged, you can use them to:
* Trigger space.vars.automations based on space.vars.activity type, completion status, or timing
* Update related space.vars.entities, such as Tickets or space.vars.objects
* Route information to the right teams, such as notifying Guest Services about allergy-related notes
* Power reporting and space.vars.dashboards with accurate, real-world interaction data
By logging Activities consistently, Timelines become actionable. Instead of static space.vars.entities, they drive space.vars.automation, insights, and coordinated responses across teams.
***
## Logging Activities Capabilities By Role
{% columns %}
{% column %}
#### Admins
* Configure space.vars.activity types that can be logged, including required fields and associations
* Define which space.vars.objects (space.vars.contacts, Guests, Tickets, space.vars.objects) appear on logged space.vars.activities
* Control permissions for who can log, edit, or complete space.vars.activities
* Ensure logged space.vars.activities display correctly on space.vars.timelines and in reports
* Maintain consistency in how interactions, purchases, and notes are recorded across teams
{% endcolumn %}
{% column %}
#### Technical Builders
* Log space.vars.activities programmatically using the API
* Trigger space.vars.workflows and space.vars.automations based on logged space.vars.activity events
* Enrich logged space.vars.activities with data from external systems or integrations
* Update related space.vars.entities automatically when space.vars.activities are logged
* Use logged space.vars.activity data as inputs for reporting, space.vars.dashboards, and downstream processes
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back Into Your Industry
In the space.vars.Theme\_park\_name example, logging the fried dough purchase captures more than a completed transaction. It captures who was involved, what happened, when it happened, and any important context, such as a guest’s allergy-related question. That logged interaction becomes part of the family’s space.vars.timeline and informs future decisions.
The same logging pattern applies across industries where completed interactions, conversations, and outcomes need to be preserved and understood in context.
{% tabs %}
{% tab title="Insurance" %}
Logging a fried dough purchase is similar to logging completed client interactions in insurance.
Examples include:
* A call where a policyholder asks about coverage limitations
* A completed claim discussion with notes on next steps
* A client question that signals potential risk, coverage gaps, or follow-up needs
Just as the allergy question adds important context at space.vars.Theme\_park\_name, logged insurance Activities capture details that support compliance, continuity of service, and accurate reporting.
{% endtab %}
{% tab title="Healthcare" %}
At space.vars.Theme\_park\_name, logging captures what happened during a guest visit. In healthcare, logging space.vars.activities documents completed care interactions and patient communication.
Examples include:
* A completed appointment with provider notes
* A patient question about medication, allergies, or side effects
* A follow-up conversation after a procedure or lab result
Logging these interactions ensures care teams share the same patient history and can make informed decisions over time.
{% endtab %}
{% tab title="Financial Services" %}
The fried dough interaction represents a completed moment with meaningful context. In financial services, Logged space.vars.activities capture completed client touchpoints and decision history.
Examples include:
* A client meeting discussing portfolio changes
* A completed compliance or suitability review
* A conversation revealing new financial goals or concerns
By logging space.vars.activities consistently, financial teams preserve decision context, support regulatory accountability, and maintain accurate client space.vars.timelines.
{% endtab %}
{% endtabs %}
***
## What's Next?
Next, we’ll cover [Reporting in Kizen](/docs/kizen-basics/kizen-in-action/reporting-in-kizen-or-kizen-in-action), where you’ll learn how to build, customize, and analyze reports to gain visibility into your data, space.vars.activity performance, and space.vars.automation outcomes.
# Reports in Kizen | Kizen Basics
Build Kizen dashboards to monitor activities, track records, and report on live operational data using Dashlets, filters, and role-based sharing settings.
## Overview
space.vars.dashboards provide a visual way to monitor activity, performance, and operational data in space.vars.Kizen\_company\_name. By combining charts, tables, and space.vars.activity views into a single workspace, space.vars.dashboards allow teams to track important information without navigating through multiple space.vars.entities or pages.
In this walkthrough, you will build a space.vars.dashboard for space.vars.Theme\_park\_name that displays scheduled space.vars.activities and guest information. You will create a space.vars.dashboard, add dashlets, and configure views that help park staff track upcoming guest events, monitor reservations, and quickly view customer data established in previous tutorials.
### Why This Matters
space.vars.dashboards help organizations turn operational data into actionable insight. Using space.vars.dashboards allows teams to:
* Monitor scheduled space.vars.activities and upcoming work
* Track space.vars.entity data such as space.vars.contacts, reservations, and guest information
* Identify operational issues quickly
* Share a common view of key business metrics across teams
* Reduce time spent navigating between individual space.vars.entities
For space.vars.Theme\_park\_name, the space.vars.dashboard ensures staff can easily monitor upcoming guest space.vars.activities and quickly access related space.vars.contact information. Instead of manually reviewing individual space.vars.entities, the team can see operational status in one place.
### Before You Begin
To build a space.vars.dashboard, you must:
* Be an Admin or Technical Builder with space.vars.dashboard creation permissions
* Have completed:
* [Create Your First Contact Record](/docs/kizen-basics/kizen-in-action/create-your-first-contact-record-or-kizen-basics)
* [Create Your First Object](/docs/kizen-basics/kizen-in-action/create-your-first-object-or-kizen-basics)
* [Create Your First Record](/docs/kizen-basics/kizen-in-action/create-your-first-record-or-kizen-basics)
* [Create Your First Workflow Object](/docs/kizen-basics/kizen-in-action/create-your-first-workflow-or-kizen-in-action)
* [Schedule Your First Activity](/docs/kizen-basics/kizen-in-action/scheduling-your-activity-and-timelines-or-kizen-in-action)
* [Log Your First Activity](/docs/kizen-basics/kizen-in-action/tracking-your-activity-in-timelines-or-kizen-in-action)
* You should already have:
* space.vars.contact space.vars.entities for Marcus, Elena, Sofia, and Caleb
* Ticket, Concession, and Ride Waiver space.vars.objects and space.vars.entities with associations to your space.vars.contact space.vars.entities.
* Scheduled and Logged Activities linked to tickets or various guest experiences
***
## Building a Dashboard
{% stepper %}
{% step %}
#### Navigate to **Dashboard**
In the navigation menu, select **Dashboard**.
space.vars.dashboard modal, enter the following:
* **Dashboard Name:** Flywheel Operations space.vars.dashboard
* **Make Private:** Disabled
{% hint style="info" %}
**Note:** When **Make Private** is enabled, the space.vars.dashboard is hidden from search and other users cannot request access. Access must be granted manually.
{% endhint %}
* **Customize Styles:** Disabled
{% hint style="info" %}
**Note:** When **Customize Styles** is enabled, you can adjust the space.vars.dashboard’s visual appearance, including chart colors, trend lines, donut segments, headers, and other theme elements.
{% endhint %}
* **Sharing settings:**
* **All Team Members:** View
* **Specific Roles:** Blank
* **Specific Team Members:** Blank
{% hint style="info" %}
**Note:** **Share Settings** allow you to grant space.vars.dashboard access to specific team members, roles, or groups. For this tutorial, all team members have been given **view access** to the **Flywheel Operations Dashboard**.
{% endhint %}
Select **SAVE**
space.vars.dashboard has been created.
{% endstep %}
{% step %}
#### Add an Activity Dashlet
Select **ADD DASHLET**
Enter the following:
* **Area:** Activities
* **Report Type:** Number of Activity Submissions
* **Choose Activity:** Ride Waiver Confirmation
space.vars.Theme\_park\_name staff to monitor all Ride Waiver submissions. Because Marcus has submitted those ride waiver confirmations before for his kids, your graph will look like this (with different dates):
space.vars.Theme\_park\_name Operations Dashboard is now ready for use.
***
## Apply What You've Learned
With the Waiver Submissions Dashlet now complete, it’s time to apply what you have learned to create a graph for tracking ticket purchases using the same steps. These space.vars.objects will track purchases made in the park and adherence to safety policies.
Use the information below to set it up.
* **Area:** Activities
* **Report Type:** Number of Activity Submissions
* **Choose Activity:** Purchase Tickets
* **Dashlet Filters:** 0 Selected
* **Assigned to Employee with Role:** *Blank*
* **Assigned to Employee:** *Blank*
When you complete this process, you should have two graphs that look like this (with different dates).
space.vars.dashboards do more than display data. They surface the results of space.vars.automations across the platform.
In the space.vars.Theme\_park\_name example, when a guest books an adventure experience, several automated processes may occur. A space.vars.contact space.vars.entity may be created or updated, an space.vars.activity may be scheduled for the reservation, and an space.vars.automation may send a confirmation email to the guest. Because these actions are connected to space.vars.entities and space.vars.activities, space.vars.dashboards can display the resulting data as it occurs.
When space.vars.dashboards reflect live operational data, teams can use them to:
* Monitor activities created by space.vars.automations
* Track space.vars.entity updates generated by automated processes
* Identify upcoming tasks that require staff attention
* Observe operational metrics produced by automated events
By surfacing this information in one place, space.vars.dashboards provide operational visibility. Instead of reviewing individual space.vars.entities or processes, teams can monitor space.vars.automations as they unfold and respond quickly when action is required.
***
## Dashboard Capabilities by Role
{% columns %}
{% column %}
#### Admins
* Configure which space.vars.dashboards are available to teams and departments
* Define sharing settings and visibility for space.vars.dashboards and dashlets
* Control permissions for who can create, edit, or view space.vars.dashboards
* Ensure space.vars.dashboards display the correct space.vars.entity data and space.vars.activity information
* Maintain consistency in how operational metrics and reports are presented across teams
{% endcolumn %}
{% column %}
#### Technical Builders
* Configure dashlets to display space.vars.entities, space.vars.activities, and operational data
* Apply filters, views, and sorting logic to shape space.vars.dashboard reporting
* Use space.vars.dashboards to monitor data generated by space.vars.automations
* Ensure space.vars.dashboards reflect changes to space.vars.objects, fields, and relationships
* Use space.vars.dashboard data to support reporting, operational monitoring, and downstream processes
* Create space.vars.dashboards that can be shared with other team members in the business.
{% endcolumn %}
{% endcolumns %}
***
## Tying It Back to Your Industry
In the space.vars.Theme\_park\_name example, the space.vars.dashboard provides a central place for staff to monitor scheduled guest activities and quickly view related space.vars.contact information. The same space.vars.dashboard pattern applies across industries where teams need visibility into operational work, upcoming tasks, and customer space.vars.entities.
{% tabs %}
{% tab title="Insurance" %}
Tracking scheduled guest activities in a space.vars.dashboard is similar to monitoring policy and service space.vars.activities in insurance.
For example:
* A space.vars.dashboard showing new policy applications awaiting review
* A space.vars.dashboard tracking claims processing activities and required follow-ups
* A space.vars.dashboard displaying scheduled agent outreach or client meetings
* A space.vars.dashboard highlighting upcoming policy renewal reminders
Just as space.vars.Theme\_park\_name staff monitor upcoming guest reservations, insurance teams use space.vars.dashboards to monitor policy space.vars.activity and ensure critical milestones are not missed.
{% endtab %}
{% tab title="Healthcare" %}
Healthcare organizations use space.vars.dashboards to maintain visibility into patient care coordination and operational workflows.
For example:
* A space.vars.dashboard showing scheduled patient appointments for the day
* A space.vars.dashboard tracking follow-up care activities after procedures
* A space.vars.dashboard monitoring insurance verification tasks before visits
* A space.vars.dashboard displaying care team workloads and patient assignments
Just as space.vars.Theme\_park\_name staff monitor guest experiences and reservations, healthcare teams monitor patient care activities and operational readiness.
{% endtab %}
{% tab title="Financial Services" %}
Financial services teams rely on space.vars.dashboards to track client engagement and advisory workflows.
For example:
* A space.vars.dashboard displaying new client onboarding activities
* A space.vars.dashboard tracking scheduled portfolio review meetings
* A space.vars.dashboard monitoring compliance follow-ups and documentation reviews
* A space.vars.dashboard showing the investment workflow and upcoming client interactions
Just as space.vars.Theme\_park\_name staff use space.vars.dashboards to track guest interactions and reservations, financial services teams use dashboards to maintain visibility into client relationships and advisory activities.
{% endtab %}
{% endtabs %}
Regardless of industry, dashboards provide a centralized view of operational activity, helping teams monitor work, manage customer relationships, and ensure important steps occur at the right time.
***
## Congratulations
You've completed space.vars.Kizen\_company\_name Basics and now have a working foundation in space.vars.Kizen\_company\_name and the core skills to start building for your own organization!
From here, you can explore the rest of the space.vars.Kizen\_company\_name documentation at your own pace. Concept topics go deeper on how individual features work, and additional guides cover more advanced configuration as your needs grow.
# Environments
Understand Kizen API environments, including GO and FMO production instances, API base URLs, environment-specific authentication, and common environment mismatch errors.
{% hint style="success" %}
**Audience:** Admins, Developers, Solution Architects
**Purpose:** Explains how space.vars.Kizen\_company\_name production environments work so you can correctly select API base URLs, configure authentication, and avoid cross-environment integration errors.
{% endhint %}
## Overview
The space.vars.Kizen\_company\_name environment refers to the specific production instance of the space.vars.Kizen\_company\_name platform where a business account is hosted. Each environment has its own Web App URL and API base URL and operates as a separate production cluster.
When building integrations, selecting the correct environment is critical. API requests sent to the wrong environment will fail authentication or return unexpected results because credentials, data, and configurations are not shared across environments.
### Available Environments
space.vars.Kizen\_company\_name currently supports the following production environments:
| Environment | API Base URL | Web App URL | Typical Use Case |
|---|---|---|---|
| GO | https://app.go.kizen.com/api | https://go.kizen.com | Primary production environment |
| FMO | https://app.fmo.kizen.com/api | https://fmo.kizen.com | Alternate production environment, specific to FMOs |
space.vars.Kizen\_company\_name environment is fully isolated. Databases, business accounts, users, API tokens, and OAuth contexts are not shared across environments. Data created in one environment is not accessible from another.
Authentication is environment-specific. Credentials are issued within a specific environment and are valid only for that environment’s API base URL. A token generated in `go` cannot authenticate against `fmo`.
If you receive a `401 Unauthorized` response and your credentials are correct, verify that:
* The API base URL matches your UI environment
* The token was generated in the same environment you are calling
For additional guidance, see the [Authentication](/docs/developers/authentication) documentation.
***
## Testing, Deployment, and Troubleshooting
space.vars.Kizen\_company\_name does not provide public sandbox environments, so integrations operate directly against production environments. Use a non-critical production account for development testing and avoid destructive operations on live business data. Before deploying updates, confirm that environment variables reference the correct API base URL and that environment-specific credentials are properly configured. Misconfigured environment values are a common cause of integration failures.
Common symptoms of an environment mismatch include `401 Unauthorized` errors despite valid credentials, `404 Not Found` responses for known space.vars.entities, missing data, or OAuth flows that succeed while API calls fail. In most cases, the API request is being sent to the wrong environment. Verify the Web App URL, the API base URL, and the environment where the token was generated before investigating further.
space.vars.Kizen\_company\_name environment your business is hosted in by checking the Web App URL and verifying the matching API base URL. From there, generate credentials within that environment and proceed to [Authentication](/docs/developers/authentication) before making your first API call.
space.vars.Kizen\_company\_name API, token-based authentication and OAuth2, including setup steps, required headers, and security best practices.
{% endhint %}
## **Overview**
Every request to the space.vars.Kizen\_company\_name API must be authenticated. Authentication tells the API who is making the request, which business account to scope it to, and whether that user has permission to access the requested data.
There are two supported methods:
* **Token-based authentication**
* Recommended starting point for most integrations
* **OAuth2**
* More secure option for production integrations
This topic covers both methods and helps you decide which one fits your use case.
***
## **Token-Based Authentication**
Token-based authentication is the simplest and most common way to get started with the space.vars.Kizen\_company\_name API. It uses an API key tied to a specific space.vars.Kizen\_company\_name user, along with that user's business ID and user ID. All three are required on every request.
### **Setting Up a Dedicated API User**
Before creating an API key, it’s strongly recommended to set up a dedicated user specifically for API access rather than using a personal account. API keys inherit the permissions of the user they belong to, so using a personal account would grant the integration full access to everything that user can do.
Instead, create a dedicated API user with a tightly scoped permission group that includes only what the integration needs. Then assign that permission group to the API user and generate the API key from that account. This approach limits access, and makes it easier to manage, audit, and revoke permissions without affecting other users.
### **Required Headers**
Once you have an API key, every call to the space.vars.Kizen\_company\_name API must include the following three headers:
* `X-API-KEY`**:** authenticates the request, acting as the password for the user ID
* `X-BUSINESS-ID`**:** scopes the request to the correct space.vars.Kizen\_company\_name business account
* `X-USER-ID`**:** identifies the user, determining which records and features are accessible based on their permissions
The business ID and user ID can both be found on the My Profile page when viewing an existing API key. For more information on Generating or Revoking API Keys, see [Generate API Credentials](/docs/developers/building-with-apis/generating-api-credentials).
***
## **OAuth2 Authentication**
OAuth2 is the more secure option for production integrations. Unlike token-based authentication, it keeps static credentials out of your integration entirely. It uses an Authorization Code flow with Proof Key for Code Exchange (PKCE), short-lived access tokens, and automatic token rotation, making it better suited for integrations that require delegated access or need to act on behalf of multiple users.
### **How It Works**
Access tokens expire after 1 hour and are refreshed using a refresh token, which expires after 48 hours. Each refresh issues a new refresh token and invalidates the old one, with a 5-minute grace period to handle network failures.
Because of this rotation behavior, always use a singleton pattern when refreshing tokens to avoid race conditions.
### **Configuration**
Once your client application has been set up, configure your integration as follows:
* **Authorize URI**: space.vars.Kizen\_company\_name. To get started, contact your space.vars.Kizen\_company\_name support representative with the following information:
* Your application name
* Environments you need to support
* Redirect URI or URIs your integration will use
space.vars.Kizen\_company\_name will then provide you with a Client ID and Secret via secure communication.
Access and refresh tokens can be revoked at any time via API call or through the My Profile page in space.vars.Kizen\_company\_name.
***
## **What's Next**
Now that you understand how authentication works, start with [Generating your API Credentials](/docs/developers/building-with-apis/generating-api-credentials), then move on to [Create Your First API Call](/docs/developers/building-with-apis/creating-your-first-api-call) to test your credentials and confirm everything is working in the test environment.
# Build with APIs
Explore the Kizen API — learn how it works, key concepts like Objects, Records, and Permissions, and the authentication methods needed to start building integrations.
{% hint style="success" %}
**Audience:** Administrators and Developers
**Purpose:** Provides an overview of space.vars.Kizen\_company\_name's APIs, including how it works, key concepts, and available authentication methods, to help administrators and developers understand what they need before building integrations.
{% endhint %}
## Overview
space.vars.Kizen\_company\_name's APIs give you programmatic access to the data, space.vars.objects, and space.vars.automation engine that powers the space.vars.Kizen\_company\_name platform. Using our APIs, allows you to connect to external systems, sync data, trigger space.vars.workflows, and build custom integrations without touching the space.vars.Kizen\_company\_name UI.
### What You Can Do with Kizen's APIs
space.vars.Kizen\_company\_name's APIs support a wide range of operations across the platform, including:
* Reading and writing space.vars.entities for any space.vars.object or space.vars.contact
* Retrieving space.vars.object schemas, field definitions, and workflow configuration
* Triggering space.vars.automations programmatically
* Scheduling and managing space.vars.activities
* Checking user permissions at runtime
* Extending the platform through webhooks and plugins
### How the APIs Work
space.vars.Kizen\_company\_name's APIs are REST APIs. All requests are made over HTTPS to a base URL. The URL you use depends on your space.vars.Kizen\_company\_name [environment](/docs/developers/environments). The following is an example:
```
https://app.go.kizen.com/api/
```
Requests and responses use JSON. Every API call must include three credentials passed as HTTP request headers — an **API Key**, a **Business ID**, and a **User ID**. Together, these three values tell the API who is making the request, which business account to scope it to, and whether that user has permission to access the requested data.
| Header | Purpose |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `X-API-KEY` | Authenticates the request — acts as the password for the User ID |
| `X-BUSINESS-ID` | Scopes the request to the correct space.vars.Kizen\_company\_name business account |
| `X-USER-ID` | Identifies the user, determining which space.vars.entities and features are accessible based on their permissions |
All three headers are required on every request. Generating these credentials is covered in [Generate API Credentials](/docs/developers/building-with-apis/generating-api-credentials).
***
## API Fundamentals
Before diving into API calls, a few core concepts are worth understanding.
Here's a table summarizing the API Fundamentals concepts:
| Concept | Definition | Key Detail |
| ----------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Objects](/docs/concepts/objects) | Tables in your data model | Configured by you or your team; space.vars.contact space.vars.object is a special type for storing individual's information |
| [Records](/docs/concepts/objects/records) | Rows within an Object | Represents a single entry of data within an space.vars.object |
| [Object Identifiers](/docs/concepts/objects/object-data-model#how-objects-are-identified) | Unique ID (UUID) or API Name that identifies every Object | API Names are preferred — easier to read, resilient to data model changes, and usable across businesses with different credentials |
| [Permissions](/docs/concepts/objects/object-configuration/object-permissions) | Access rules that control what data a request can read or modify | Based on the User ID in request headers; a dedicated API user with a purpose-built permission group is strongly recommended |
space.vars.Kizen\_company\_name supports two authentication methods:
* Token-based authentication is quick to set up, passing a static API Key, Business ID, and User ID as headers on every request.
* OAuth 2.0 is the more secure option for production integrations, using an Authorization Code flow with PKCE (Proof Key for Code Exchange) and automatic token expiration.
For more information see, [Authentication](/docs/developers/authentication).
***
## Topics In This Section
* [Generate API Credentials](/docs/developers/building-with-apis/generating-api-credentials): Create your API Key, Business ID, and User ID in the space.vars.Kizen\_company\_name UI
* [Create Your First API Call](/docs/developers/building-with-apis/creating-your-first-api-call): Use those credentials to make a live, authenticated API request
***
## What's Next
Start with [Generate API Credentials](/docs/developers/building-with-apis/generating-api-credentials) — once your credentials are ready, you have everything you need to make your first API call.
space.vars.Kizen\_company\_name UI, including an API Key, User ID, and Business ID, required to authenticate requests to the space.vars.Kizen\_company\_name API.
{% endhint %}
## Overview
API credentials authenticate every request you make to the space.vars.Kizen\_company\_name API. Before you can make your first API call, you need three credentials: an **API Key**, a **Business ID**, and a **User ID**. space.vars.Kizen\_company\_name generates all three at the same time from the **API Connections** page.
### Before You Begin
Generating API credentials requires the appropriate permission in your space.vars.Kizen\_company\_name account. If you do not see the API Connections tab, contact your space.vars.Kizen\_company\_name administrator to have the permission enabled for your role.
It is also strongly recommended that you generate credentials for a dedicated API user rather than your personal account. A dedicated API user limits the integration's access to only what it needs and makes credential management easier to audit over time. See your space.vars.Kizen\_company\_name administrator to set this up before proceeding.
***
## Generate Your API Credentials
{% stepper %}
{% step %}
#### In space.vars.Kizen\_company\_name, select your Profile Avatar
space.vars.Kizen\_company\_name business account
space.vars.Kizen\_company\_name API using an API Key, Business ID, and User ID, using the Retrieve space.vars.object Details by ID endpoint as a working example.
{% endhint %}
## Overview
Now that you have your API credentials, you are ready to make your first authenticated request to the space.vars.Kizen\_company\_name API. This topic walks you through assembling your credentials, choosing an endpoint, and executing a live API call using the [Retrieve Object Details by ID](/docs/concepts/objects/object-apis/retrieve-object-details-by-id-api) endpoint as an example.
### Before You Begin
Before starting this topic, ensure you have the following ready:
* Your **API Key**, **Business ID**, and **User ID** from the **API Connections** page
* A created space.vars.object in your space.vars.Kizen\_company\_name platform. If you have not yet created one, see [Create Your First Object](/docs/kizen-basics/kizen-in-action/create-your-first-object-or-kizen-basics)
* space.vars.entity details in your space.vars.object. If you have not yet created any, see [Create Your First Record](/docs/kizen-basics/kizen-in-action/create-your-first-record-or-kizen-basics)
* The **Object ID** of the space.vars.object you want to retrieve — this is a UUID found in your space.vars.Kizen\_company\_name space.vars.object settings
* An HTTP client such as cURL, Postman, or any language-specific (e.g., Python requests, JavaScript fetch) HTTP library
### About the Example Endpoint
This topic uses the [Retrieve Object Details by ID](/docs/concepts/objects/object-apis/retrieve-object-details-by-id-api) endpoint as the example call. This endpoint returns the full schema definition for a single space.vars.object in your business, including its fields, categories, and relationship configuration. It is a safe, read-only call and will not modify any data.
| | |
| ------------ | ---------------------------------------------------------------- |
| **Method** | `GET` |
| **Endpoint** | `/api/custom-objects/{object_pk}/detail` |
| **Full URL** | `https://app.go.kizen.com/api/custom-objects/{object_pk}/detail` |
Replace `{object_pk}` with the UUID of the space.vars.object you want to retrieve.
***
## Create Your First API Call
{% stepper %}
{% step %}
#### Assemble your request headers
Every space.vars.Kizen\_company\_name API call requires the same three headers. Pull these from the credentials you generated in [Generate API Credentials](/docs/developers/building-with-apis/generating-api-credentials):
| Header | Value |
| --------------- | ---------------- |
| `X-API-KEY` | Your API Key |
| `X-BUSINESS-ID` | Your Business ID |
| `X-USER-ID` | Your User ID |
| `accept` | application/json |
| {% endstep %} | |
{% step %}
#### Make the request
Choose your preferred tool below. Replace the placeholder values with your actual credentials and the space.vars.object's `entity_id`, which you can find in the **General Settings** page of the space.vars.object when viewing it in edit mode.
{% tabs %}
{% tab title="cURL" %}
```
cURL -X GET "https://app.go.kizen.com/api/custom-objects/{object_pk}/detail" \
-H "accept: application/json" \
-H "X-API-KEY: your_api_key_here" \
-H "X-BUSINESS-ID: your_business_id_here" \
-H "X-USER-ID: your_user_id_here"
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
url = "https://app.go.kizen.com/api/custom-objects/{object_pk}/detail"
headers = {
"accept": "application/json",
"X-API-KEY": "your_api_key_here",
"X-BUSINESS-ID": "your_business_id_here",
"X-USER-ID": "your_user_id_here"
}
response = requests.get(url, headers=headers)
print(response.status_code)
print(response.json())
```
{% endtab %}
{% tab title="JavaScript" %}
```javascript
const response = await fetch(
"https://app.go.kizen.com/api/custom-objects/{object_pk}/detail",
{
method: "GET",
headers: {
"accept": "application/json",
"X-API-KEY": "your_api_key_here",
"X-BUSINESS-ID": "your_business_id_here",
"X-USER-ID": "your_user_id_here"
}
}
);
const data = await response.json();
console.log(data);
```
{% endtab %}
{% endtabs %}
{% endstep %}
{% step %}
#### Receive and understand the response
A successful request returns HTTP **200** with a JSON body containing the full schema definition of the space.vars.object. Key fields in the response include:
| Field | Description |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `id` | The UUID of the space.vars.object |
| `object_name` | The display name of the space.vars.object |
| `object_type` | Either `pipeline` or `standard` |
| `fields` | An array of all field definitions on the space.vars.object, including field type, display name, and access rules |
| `field_categories` | The category groupings fields are organized into |
| `pipeline` | Pipeline configuration, including stages, if the space.vars.object has a space.vars.workflow |
| `access` | Whether the current user can view, edit, or remove this space.vars.object |
**Example Responses**
{% tabs %}
{% tab title="cURL" %}
cURL prints the raw JSON response directly to the terminal:
```
{
"id": "123e4567-e89b-12d3-a456-426614174000",
"object_type": "pipeline",
"object_name": "Contacts",
"entity_name": "Contact",
"is_custom": false,
"allow_relations": true,
"fields": [...],
"field_categories": [...],
"pipeline": {...},
"access": {
"view": true,
"edit": true,
"remove": false
}
}
```
{% endtab %}
{% tab title="Python" %}
`response.json()` parses the JSON into a Python dictionary and `print()` outputs it to the console:
```python
{'id': '123e4567-e89b-12d3-a456-426614174000', 'object_type': 'pipeline', 'object_name': 'Contacts', 'entity_name': 'Contact', 'is_custom': False, 'allow_relations': True, 'fields': [...], 'field_categories': [...], 'pipeline': {...}, 'access': {'view': True, 'edit': True, 'remove': False}}
```
{% endtab %}
{% tab title="JavaScript" %}
`console.log()` outputs the parsed JSON object to the browser or Node.js console:
```javascript
{
id: '123e4567-e89b-12d3-a456-426614174000',
object_type: 'pipeline',
object_name: 'Contacts',
entity_name: 'Contact',
is_custom: false,
allow_relations: true,
fields: [...],
field_categories: [...],
pipeline: {...},
access: { view: true, edit: true, remove: false }
}
```
{% endtab %}
{% endtabs %}
{% endstep %}
{% endstepper %}
***
## Troubleshooting
If your request does not return a successful `200` response, the HTTP status code in the response will help you identify what went wrong. The most common errors when making your first API call are misconfigured credentials or an incorrect space.vars.object ID. Use the table below to diagnose and resolve the issue.
| Status Code | Likely Cause | Resolution |
|---|---|---|
401 Unauthorized | Missing or invalid X-API-KEY, wrong business_id or user_id | Verify your API Key is correct and has not been deleted, and that you have the correct business and user id. |
403 Forbidden | User does not have permission to access the space.vars.object | Check the API user's permission group in space.vars.Kizen_company_name |
404 Not Found | The object_pk does not exist or the URL is incorrect | Confirm the space.vars.object UUID and that you are using the correct environment URL |
space.vars.Kizen\_company\_name administrator to verify your credentials and permission group are correctly configured. For additional support, visit our [Where to Find Help](/docs/readme/where-to-find-help) page.
***
## What's Next
With your first API call complete, you have everything you need to start exploring the rest of the space.vars.Kizen\_company\_name API. Some good next steps include:
* Query, create, or update space.vars.entities for the space.vars.object using the space.vars.entities APIs
* Use the field identifiers returned in the response to construct space.vars.entity payloads
* Explore the full API Reference at [developer.kizen.com/api](https://developer.kizen.com/api)
* Test endpoints interactively using the Swagger docs at [app.go.kizen.com/api/docs/public/swagger](https://app.go.kizen.com/api/docs/public/swagger)
space.vars.Kizen\_company\_name exposes an MCP server so a connected assistant can work directly with your space.vars.Kizen\_company\_name data.
The current space.vars.Kizen\_company\_name MCP server is read-only and exposes tools for your Knowledge Catalogs: an assistant can list the catalogs you can access, search across them, and open a specific document. Access always follows your existing space.vars.Kizen\_company\_name permissions, so a connected assistant sees only the catalogs and content you are allowed to view.
Think of MCP as an AI-native way to reach space.vars.Kizen\_company\_name, alongside the REST API. Where the REST API is built for your code to call, the MCP server is built for an AI assistant to call on your behalf. Unlike REST, MCP doesn't guarantee backward compatibility, since the assistant is expected to discover available tools each time it connects.
## What You Can Do with space.vars.Kizen\_company\_name's MCP Server
Once an assistant is connected, it can:
* List the Knowledge Catalogs you have access to.
* Run a semantic search across one or all of those catalogs.
* Retrieve the full text of a specific knowledge document.
The current tools are read-only. The assistant can read your knowledge, but it can't create, edit, or delete anything in space.vars.Kizen\_company\_name.
## How the MCP Server Works
The space.vars.Kizen\_company\_name MCP server has one endpoint per environment. Choose the host that corresponds to your space.vars.Kizen\_company\_name environment:
* `POST https://app.go.kizen.com/api/mcp/readonly`
* `POST https://app.fmo.kizen.com/api/mcp/readonly`
If your business uses a custom domain, use that domain's API host instead of `app.go.kizen.com` or `app.fmo.kizen.com`. The `readonly` portion of the URL selects the server's read-only configuration.
Requests use JSON-RPC 2.0 over HTTPS POST, and the assistant follows a simple pattern: It connects, discovers the available tools, then calls a tool and reads the result.
## Authentication
For authentication, the MCP server supports OAuth 2.1 for connection to external AI clients such as Claude and ChatGPT. You connect once, sign in through the browser, choose a business, and approve, with no API key to manage.
For additional information, see the [Authentication](/docs/developers/authentication) page.
## Permissions and Data Scoping
A connected assistant acts as you. It can reach only the Knowledge Catalogs you have View permission on, and only within the business you connected to. Nothing is shared across businesses, and the assistant never gains access beyond your own.
## Available Tools
For each tool's inputs, outputs, and behavior, see the [MCP Tools](/docs/developers/build-with-the-mcp/mcp-tools) page.
***
## What's Next
Start by connecting a client in [Connect an AI Assistant](/docs/developers/build-with-the-mcp/connect-an-ai-assistant), then head to [MCP Tools](/docs/developers/build-with-the-mcp/mcp-tools) for the exact inputs and outputs of each tool.
space.vars.Kizen\_company\_name through the space.vars.Kizen\_company\_name MCP server so it can search your Knowledge Catalogs on your behalf. Connect your client using OAuth, or use the API-key method as an alternative for testing.
***
## Before You Begin
Make sure you have:
* An active space.vars.Kizen\_company\_name account with View permission on the catalogs you want the assistant to reach.
* A supported MCP client: the Claude app or Claude.ai, Claude Code, ChatGPT (via the Codex desktop app), or Gemini (via the Antigravity app).
* The MCP server endpoint URL. For more information, see [How the MCP Server Works](https://developer.kizen.com/docs/developers/build-with-the-mcp#how-the-mcp-server-works).
***
## Connect with Claude (Custom MCP Connector)
Whether you can add a custom MCP connector depends on your Claude account. On a personal account you can add your own. In a managed Team or Enterprise workspace, an administrator controls whether members can add custom connectors. If it's disabled, you'll see your existing connectors but no **Add custom connector** option, and an owner must add it for the workspace.
1. **Open Connector Settings**. In Claude, go to **Settings**, then **Connectors**.
2. **Add the Kizen MCP Connector**. Select **Add** **custom connector**, paste the MCP server URL: space.vars.Kizen\_company\_name handles sign-in through OAuth.
3. **Connect and Authorize**. Select **Connect**. Claude opens space.vars.Kizen\_company\_name sign-in in your browser. Sign in, choose the business you want, and authorize. When you return, the MCP connector lists your catalogs. You can confirm by asking Claude to list the catalogs on the space.vars.Kizen\_company\_name MCP.
***
## Connect with Claude Code (CLI)
Add the server from the command line, then complete the browser sign-in when prompted:
```
claude mcp add --transport http kizen-mcp https://app.go.kizen.com/api/mcp/readonly/ --scope user
```
Sign in, select a business, and approve.
***
## Connect with ChatGPT (Codex Desktop App)
MCP can't be configured in ChatGPT on the web. Instead, use the Codex desktop app.
1. **Open MCP settings**. In the Codex app, go to **Settings** > **Integrations & MCP** and select **Add** server.
2. **Add the Kizen server**. Give it a name (for example, "space.vars.Kizen\_company\_name"), choose **Streamable HTTP** as the type, paste the MCP server URL, and **Save**.
3. **Authenticate**. Codex prompts you to Authenticate. Complete the OAuth sign-in in your browser, and then, in a new chat, confirm by asking Codex to list the catalogs on the space.vars.Kizen\_company\_name MCP.
***
## Connect with Gemini (Antigravity App)
Configure MCP in the Antigravity app (not the Gemini browser). Antigravity's Add MCP screen lists published partner connectors. To add a custom server, edit the MCP config file.
1. **Open the MCP config**. Go to **Settings** > **Customizations** > **Installed MCP Servers** > Open **MCP config**.
2. **Add the Kizen server**. Add an entry using the `serverUrl` key:
```
{ "mcpServers": { "kizen": { "serverUrl": "https://app.go.kizen.com/api/mcp/readonly" } } }
```
3. **Authorize**. Antigravity signs in with OAuth (PKCE) and a local callback (port 8080). Authorize in the browser when prompted. The catalogs load. You can also let the agent sign in for you. For example: Add a custom MCP named space.vars.Kizen\_company\_name at space.vars.Kizen\_company\_name MCP server exposes three tools for working with Knowledge Catalogs, which are sets of information sources that you can share across your business. Admins control which roles and team members can query each catalog. A connected assistant discovers these tools automatically and calls them as needed to answer questions from the catalogs you are allowed to access.
## Why Would I Use These Tools?
Use these tools to let an AI assistant answer questions from your space.vars.Kizen\_company\_name knowledge without anyone copying content out of space.vars.Kizen\_company\_name. The assistant finds the right catalog, searches it, and pulls the source document, all scoped to what you are allowed to see.
### listCatalogs
Lists the Knowledge Catalogs the connected user can access.
Inputs: none.
Returns: a list of the catalogs the user can access, with a total count, and for each catalog its `id`, `api_name`, and `description`.
### searchCatalog
Runs a semantic search across one or all accessible catalogs and returns the most relevant content.
Inputs:
* `query` (string, required): the search text.
* `n` (integer, optional, default 10): maximum number of results.
* `catalog` (string, optional): limit the search to one or more catalogs, by API name or UUID. Accepts multiple comma-separated values. To search all accessible catalogs, omit the `catalog` input.
Returns: matching content chunks as plain text, each with a source description, a snippet, and a relevance score.
### getDocument
Retrieves the full text of a single knowledge source.
Inputs:
* `source_id` (string, required): the source identifier, obtained from a `searchCatalog` result.
Returns: the source's metadata and its full, concatenated content.
## Behavior and Details
* Response format: All tools return plain text, not JSON, optimized for AI consumption.
* Tool annotations: Each tool advertises MCP annotations such as `readOnlyHint: true` and `destructiveHint: false`, so clients can tell these are safe, read-only tools.
* Permissions and scope: Results include only catalogs the user has View permission on, scoped to the authenticated business.
* Performance: A search adds roughly 200 to 500 ms for embedding.
* Errors: An unauthenticated request returns a JSON-RPC error. An unknown configuration slug returns 403.
***
## What's Next
For how the server and authentication work, see [Build with MCP](/docs/developers/build-with-the-mcp), or follow [Connect an AI Assistant](/docs/developers/build-with-the-mcp/connect-an-ai-assistant) to connect a client.
space.vars.Kizen\_company\_name permissions work and how to retrieve a user’s permissions using the API.
{% endhint %}
## Overview
space.vars.Kizen\_company\_name's highly configurable permissions engine allows for fine-grained access control to objects, entities, and actions that can be taken. When using the API, it’s important to be aware what permissions the current user has.
To fetch the user’s current permissions, make a GET call to `/api/auth/access`. This endpoint takes no additional parameters, and simply returns a JSON object with the current user’s permissions:
```bash
curl -X GET "https://app.go.kizen.com/api/auth/access" \
-H 'accept: application/json'
```
The JSON response includes a number of fields that describe the user’s permissions:
### Section Permissions
The `sections` value in the JSON has permission information for specific features and parts of the app. These allow or deny access to things like dashboards, homepages, custom object creation, and other core features.
There are other permissions types you can set as well. See the following topics for more information on them:
* [Object Permissions](/docs/concepts/objects/object-configuration/object-permissions)
* [Contact Permissions](/docs/concepts/objects/contacts/contact-permissions)
* [Record Permissions](/docs/concepts/objects/records/record-permissions)
***
## What's Next
You can apply this information when building integrations, space.vars.automations, or plugins that need to respect user access and authorization rules within space.vars.Kizen\_company\_name.
space.vars.entity distinguished by its `account_type` field. Any value starting with `service_` is treated as a service account. Service accounts carry permission groups, can authenticate via API, and appear in the space.vars.timeline, but are excluded from billing counts, the public employee list, and (by default) team typeahead.
For a non-technical introduction to service accounts, see the [Service Accounts](https://support.kizen.com/support/solutions/articles/154000255193-service-accounts-overview) support article.
### Account Types
Two account types exist:
| Type | Description |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `service_automation` | The **Agentic Workflow Code Account**, auto-provisioned per business. Used by Code Steps. Cannot be deleted, renamed, or have its `api_name` changed. |
| `service_integration` | **Integration accounts**, created manually or via API for external integrations such as Zapier or custom scripts. |
A service account's status is either **Active** or **Suspended**. Status cannot be changed manually; service account is suspended automatically when its associated integration is disabled.
**Email is auto-generated** and never used for login. The default domain is `serviceaccounts.kizen.com`
***
## Kizen API Access from Code Steps
You do not need to create or manage an integration service account to call Kizen APIs from an space.vars.automation Code Step. The platform provides a preconfigured client, `kizen.api`, that authenticates automatically as the business's space.vars.automation Code Account.
* **No integration secrets needed.** Do not create a separate integration service account just to call Kizen from a code step.
* **Use** `kizen.api` **directly.** It is preconfigured with the space.vars.automation service account; you do not create it, configure it, or pass credentials.
* **The API root URL is built in.** Pass only the path, not the full URL.
* Correct: `res = kizen.api.get("/custom-objects")`
* Incorrect: `res = kizen.api.get("https://app.fmo.kizen.com/api/custom-objects")`
The client supports the standard HTTP verbs — `get`, `post`, `patch`, `put`, `delete` — and returns response space.vars.objects that behave like standard `requests` responses, with `.json()` and `.raise_for_status()` available.
Here's an example request:
```python
res = kizen.api.get("/custom-objects")
res.raise_for_status()
number_of_custom_objects = res.json()['count']
```
***
## Authentication
Authentication is handled automatically for each account type:
* **Agentic Workflow Code Account:** Uses short-lived signed keys minted per execution when calling the platform via `kizen.api`. No credential management is required.
* **Integration Service Accounts:** Use stored API keys. Each account supports up to two keys (primary and secondary). Rotating a key promotes the new key to primary and demotes the previous primary to secondary.
***
## Permissions and Guardrails
Management is governed by the `MANAGE_SERVICE_ACCOUNTS` settings permission. Three permission levels apply:
| Level | Allowed Actions |
| --------------- | ---------------------------------------------------- |
| **View (Read)** | List, retrieve, view primary/secondary tokens |
| **Write** | Create, update, rotate token, delete secondary token |
| **Remove** | Archive (delete) an integration account |
**Additional guardrails:**
* A service account cannot create its own API keys.
* A service account can export business config but cannot import it.
* The space.vars.automation Code Account cannot be deleted, renamed, or have its `api_name` changed.
* Service accounts are excluded from billing seat counts and the public employee list.
* Service accounts are excluded from team typeahead by default. Pass `include_service_accounts=true` to include them.
***
## What's Next
The most common next step after reading this reference is writing or modifying an space.vars.automation code step that uses `kizen.api`. See [Agentic Workflow Code Steps ](/docs/concepts/agentic-workflows/automation-code-steps)for the full authoring guide, including available helpers, runtime behavior, and patterns for working with Kizen data from inside a step.
space.vars.objects are a foundational platform data type in space.vars.Kizen\_company\_name used to model, organize, and store business information, much like a container.
Each space.vars.object defines the structure for a type of data, including its fields, relationships, and behavior. Records created from space.vars.objects represent individual real-world entities such as customers, locations, deals, or assets.
Once space.vars.objects are created, you can:
* Add custom fields to capture structured information
* Define relationships to other space.vars.objects
* Create Forms, Surveys, or space.vars.activities to collect your space.vars.object data.
* Trigger space.vars.automations
* Read and write data through APIs
***
## Objects Mastery Checklist
Explore the following topics to understand how space.vars.objects are defined and used in space.vars.Kizen\_company\_name.
**Core Knowledge**
* [ ] [What an Object represents and when to use it](/docs/concepts/objects/object-core-concepts#how-objects-are-used)
* [ ] [What a Contact Object is and how it differs from a standard ](/docs/concepts/objects/object-core-concepts#objects-vs-contacts)
* [ ] [How Objects fit into Kizen's overall data model](/docs/concepts/objects/object-data-model#data-structure)
**Object Features**
* [ ] [How to create various Workflows](/docs/concepts/objects/object-configuration/object-workflows)
* [ ] [Understanding how Records work within an Object](/docs/concepts/objects/object-data-model#records)
* [ ] [Know how custom fields define your data](/docs/concepts/objects/object-data-model#fields)
**Configuration & Data Model**
* [ ] [How Objects define schemas and associations](/docs/concepts/objects/object-data-model#data-structure)
* [ ] [How Object field types are defined](/docs/concepts/objects/object-data-model#fields)
**Relationships**
* [ ] [How Objects relate to Activities](/docs/concepts/objects/object-core-concepts#how-objects-are-used)
* [ ] [How Object relationship types affect visibility and behavior](/docs/concepts/objects/object-configuration/object-relationships#relationship-types)
**Access & Control**
* [ ] [How Object permissions affect creating, viewing, and modifying Objects](/docs/concepts/objects/object-configuration/object-permissions)
* [ ] [Understanding Team Associations](/docs/concepts/objects/object-configuration/object-relationships#team-associations)
* [ ] [How access to primary and associated records impacts visibility](/docs/concepts/objects/object-configuration/object-relationships#primary-vs-additional-relationships)
**APIs**
* [ ] [How to list and search for Objects via API](/docs/concepts/objects/object-apis/list-and-search-objects-api)
* [ ] [How to view Object Record details via API](/docs/concepts/objects/object-apis/retrieve-object-details-by-id-api)
***
## What's Next
Next, explore the [Objects Core Concepts](/docs/concepts/objects/object-core-concepts) to understand how space.vars.object fields, relationships, identifiers, and space.vars.entities are structured behind the scenes.
From there, you can dive deeper into field types and validation rules, relationship behavior, permissions and access control, API schemas for space.vars.entities, and how space.vars.contacts relate to space.vars.entities.
space.vars.objects in space.vars.Kizen\_company\_name, including how schemas, fields, space.vars.entities, and relationships work together to support scalable data models, space.vars.automation, reporting, and integrations.
{% endhint %}
## Overview
space.vars.objects are the foundation of how all data is structured in the platform. They determine what fields are available, how space.vars.entities relate to one another, and which system behaviors are enabled. space.vars.objects provide the structure, fields define the details, and space.vars.entities store the actual data.
space.vars.Kizen\_company\_name platform supports two space.vars.object configurations:
* **Standard Objects**: used to model structured data for storage, reference, and organization.
* **Workflow Objects**: used to model process-driven data that moves through stages. They extend Standard space.vars.object behavior, adding stage management and optional pipeline reporting.
The platform remains flexible and can support a wide range of use cases beyond these common patterns. For example, a Standard space.vars.object can still track values without becoming a space.vars.workflow, and a space.vars.workflow can be used without enabling value tracking. This flexibility allows you to design data models that match your business needs while maintaining consistent behavior across space.vars.automation, reporting, and integrations.
### System Behaviors
The following behaviors describe how data is structured and behaves across the platform.
* **Objects contain the structure:** space.vars.objects function like a container that holds the schema, fields, relationships, and behavior for a type of data.
* **Fields define the structure:** Fields are configured on the space.vars.object, but Field values exist only on individual space.vars.entities.
* **Records contain the data:** space.vars.entities represent individual real-world items and store the actual data entered by users or integrations.
* **Relationships connect Records:** Relationships link space.vars.entities across space.vars.objects and enable navigation, space.vars.automation, and reporting.
For more information, see [Object Data Model](/docs/concepts/objects/object-data-model).
***
## Why Objects Matter
space.vars.objects form the structural foundation of the platform’s data model and directly determine how reliable reporting, space.vars.automation, integrations, and governance function at scale.
{% columns %}
{% column %}
A well-designed space.vars.object model enables:
* Accurate reporting and space.vars.dashboards
* Predictable space.vars.automation behavior
* Scalable integrations
* Clean data governance
* Reusable configuration across teams
{% endcolumn %}
{% column %}
Poor space.vars.object design often leads to:
* Overly complex space.vars.automations
* Confusing space.vars.entity relationships
* Confusing end-user UX
* Reporting that cannot scale
* Redundant data
{% endcolumn %}
{% endcolumns %}
***
## Objects vs Contacts
space.vars.contacts are a specialized type of space.vars.object designed specifically for managing people. They behave like Standard space.vars.objects and represent a person and their data.
While fundamentally they behave similarly, there are a few key distinctions between them:
| Aspect | Contacts | Custom Objects |
| ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------ |
| Always present regardless of permissions | No | No |
| Accessible via space.vars.objects/ space.vars.entity APIs | No | Yes |
| Supports space.vars.fields | Yes | Yes |
| Can relate to other space.vars.objects | Yes | Yes |
| Schema flexibility | Limited (space.vars.workflows not available) | Fully configurable |
| Optimized for Communication, Email & SMS | Yes | No |
| Unique Identifier | Email | space.vars.entity Name |
For more information, see [Contacts](/docs/concepts/objects/contacts).
***
## How Objects Are Used
space.vars.objects support many of the platform’s most powerful capabilities, including:
* **Workflows and lifecycle tracking:** Deals, onboarding flows, ticket lifecycles, project stages
* **Cross-Object Agentic Workflows:** Triggering space.vars.entity creation or updates in one object when another changes stage
* **Activity logging with cross-Record updates:** Logging an space.vars.activity on a space.vars.contact that updates fields on a related Ticket
* **Dashboards and reporting:** Aggregated metrics and insights based on space.vars.object fields and stages
* **API integrations:** External systems creating, updating, and relating space.vars.entities programmatically
* **Complex data modeling:** Supporting domains such as insurance, healthcare, and financial services
space.vars.objects provide the abstraction layer that makes all of this possible without hardcoding business logic.
### Object Configurations
space.vars.objects share the same foundation, but behave differently based on how they are configured. The configuration you choose affects how data flows through the system, how users interact with space.vars.entities, and how reporting and space.vars.automation behave.
#### Standard Configuration
Use when space.vars.entities represent structured data that does not move through stages.
* No stages or lifecycle
* Not shown in pipeline space.vars.dashboards or board views
* Supports fields, relationships, space.vars.automations, and APIs
* Common for reference or structured data (e.g., Locations, Policies, Assets, Providers)
#### Workflow Configuration
Use when space.vars.entities represent work that moves through a process or lifecycle.
* Includes stages and board (kanban) views
* Supports stage-based space.vars.automation
* Powers space.vars.dashboards and space.vars.workflow reporting
* Optional tracking for value and percent chance to close
* Common for Deals, Tickets, Applications, Projects, Cases, Reviews, and similar processes
### Choosing the Right Object Configuration
| If your records... | Use this type |
|---|---|
| Store structured data without lifecycle | Standard Configuration |
| Move through stages and require reporting on time in stage | space.vars.workflow Configuration |
| Represent operational processes with heavy automation | space.vars.workflow Configuration |
| Need to track monetary values | Standard or space.vars.workflow Configuration with Track Entity $ Value enabled |
| Track monetary values in a sales pipeline | space.vars.workflow Configuration with Track Entity $ Value and Include % Chance to Close enabled |
space.vars.object Configurations, see [Object Data Model](/docs/concepts/objects/object-core-concepts).
***
## Object Name vs Record Name
The platform distinguishes between space.vars.object-level labels (collection names) and space.vars.entity-level labels (instance names), each used in different UI and API contexts.
space.vars.object names are primarily used for navigation and structural labeling. space.vars.entity name fields are used to represent individual instances within an space.vars.object.
In addition to display labels, every space.vars.entity is assigned a system-generated backend name, which functions as the authoritative identifier for APIs, integrations, and internal references. Implementations should rely on this backend identifier rather than display labels.
space.vars.objects also have API names. For more information see [Object API Names](/docs/concepts/objects/object-apis/object-api-names).
***
## Key Use Cases
space.vars.objects support the following industry use cases:
### Industry Examples
{% tabs %}
{% tab title="Insurance" %}
#### Insurance Teams Modeling Policy and Operational Data
space.vars.objects provide the data foundation for insurance platforms by modeling real business entities such as policies, applications, claims, and accounts. This enables structured data capture, cross-space.vars.object relationships, reporting, and automation across the entire policy lifecycle.
Insurance teams use space.vars.objects to define consistent data models that support underwriting, servicing, compliance, renewals, and integration with external systems.
#### Examples include:
* Creating a Policy space.vars.object to store structured data such as policy number, coverage type, effective dates, carrier, premium amount, and status
* Defining an Application space.vars.object to track intake details, applicant information, risk attributes, and underwriting requirements
* Modeling a Claim space.vars.object with fields for loss type, incident date, adjuster assignment, reserve amounts, and claim status
* Using a Renewal space.vars.object with a workflow configuration to have stages such as Pending Review, Offered, Accepted, and Lapsed to manage retention workflows
#### How space.vars.objects Help:
* Establish a consistent, scalable data model for policies, applications, claims, and related space.vars.entities
* Enable relationships between space.vars.entities, such as linking a policy to a contact, agency, carrier, or claim
* Support lifecycle management using an space.vars.object with a space.vars.workflow configuration for renewals, onboarding, or claims processing
* Power reporting, space.vars.dashboards, and forecasting based on structured fields like premium value, status, and stage
* Enable space.vars.automation and integrations, such as creating renewal space.vars.entities when policies near expiration or syncing policy data to external policy administration systems via APIs and webhooks
{% endtab %}
{% tab title="Healthcare" %}
#### Healthcare Teams Modeling Clinical and Operational Data
space.vars.objects provide the data foundation for healthcare space.vars.workflows by modeling real-world entities such as patients, referrals, appointments, care plans, and cases. This enables structured data capture, secure relationships between space.vars.entities, and scalable space.vars.automation across clinical and administrative processes.
Healthcare teams use space.vars.objects to define consistent data models that support care coordination, intake management, operational space.vars.workflows, and integration with external systems.
#### Examples include:
* Creating a Patient Intake space.vars.object to capture structured data such as demographics, referral source, insurance details, and consent status
* Defining a Referral space.vars.object to track referring provider, specialty, urgency level, and acceptance status
* Modeling an Appointment space.vars.object with fields for visit type, scheduled date, assigned provider, and attendance status
* Using a Care Pathway space.vars.object with a space.vars.workflow configuration to create stages such as Intake, Evaluation, Treatment, Follow-Up, and Completed
#### How Objects Help:
* Establish a consistent, scalable data model for clinical and operational space.vars.entities
* Enable relationships between space.vars.entities, such as linking patients to referrals, providers, appointments, and care plans
* Support lifecycle management using an space.vars.object with a space.vars.workflow configuration for referrals, treatment space.vars.workflows, and discharge processes
* Power reporting and space.vars.dashboards for operational visibility, such as referral volume, appointment throughput, and care outcomes
* Enable space.vars.automation and integrations, such as creating follow-up space.vars.entities when appointments are completed or synchronizing patient data with EHR systems through APIs and webhook events
{% endtab %}
{% tab title="Financial Services" %}
#### Financial Services Teams Modeling Client and Financial Data
space.vars.objects provide the data foundation for financial services workflows by modeling real-world entities such as clients, accounts, opportunities, portfolios, and service cases. This enables structured data capture, relationship modeling, reporting, and space.vars.automation across advisory, banking, and operations functions.
Financial services teams use space.vars.objects to define consistent data models that support client onboarding, relationship management, compliance tracking, and lifecycle-based engagement.
#### Examples include:
* Creating a Client Profile space.vars.object to store structured data such as household details, risk tolerance, investment goals, and regulatory classifications
* Defining an Account space.vars.object to track account types, custodians, balances, and account status
* Modeling an Opportunity space.vars.object to manage advisory engagements with fields for estimated assets, probability to close, and expected close date
* Using a Client Lifecycle space.vars.object with a space.vars.workflow configuration to create stages such as Prospect, Onboarded, Active Client, Review Due, and At Risk
#### How Objects Help:
* Establish a consistent, scalable data model for clients, accounts, opportunities, and portfolios
* Enable relationships between space.vars.entities, such as linking clients to households, accounts, advisors, and service requests
* Support lifecycle management using an space.vars.object with a space.vars.workflow configuration for onboarding, engagement management, and retention space.vars.workflows
* Power dashboards and reporting for visibility into AUM, pipeline value, client segmentation, and service performance
* Enable space.vars.automation and integrations, such as creating onboarding space.vars.entities when a client is won or synchronizing client and account data with CRMs, custodial platforms, and external financial systems through APIs and webhook events
{% endtab %}
{% endtabs %}
***
## What's Next
Learn more about working with [Records](/docs/concepts/objects/records), then explore [Custom Fields](/docs/concepts/objects/custom-fields) to extend space.vars.object schemas and [Object Permissions](/docs/concepts/objects/object-configuration/object-permissions) to manage access.
space.vars.objects are structured in space.vars.Kizen\_company\_name, including how space.vars.entitys, fields, identifiers, and relationships behave across the platform.
{% endhint %}
## Overview
space.vars.objects define the canonical data structures used across space.vars.Kizen\_company\_name to store, relate, and operate on business data. They provide the schema layer that governs how space.vars.entities are created, validated, related, and accessed.
This page defines the space.vars.objects data model, including space.vars.object definitions, space.vars.entity instances, fields, identifiers, and relationship mechanics. It builds on concepts introduced in the [Object Core Concepts](/docs/concepts/objects/object-core-concepts).
### How Objects Are Identified
space.vars.objects and space.vars.entities in space.vars.Kizen\_company\_name are identified using a combination of system-generated IDs and API-facing identifiers. Each plays a different role across the platform, including UI navigation, API operations, space.vars.automations, and data imports.
#### System-Generated Identifiers
space.vars.Kizen\_company\_name assigns immutable, system-generated IDs that uniquely identify data within a Business. These identifiers form the canonical identity layer of the platform.
Every space.vars.object and space.vars.entity has the following system-generated identifiers:
* **`custom_object_id`** – schema-level identifier
* **`record_id`** – instance-level identifier
#### **What Is A** `custom_object_id`?
A `custom_object_id` uniquely identifies an space.vars.object definition. It is used internally by the platform and APIs to reference the space.vars.object’s schema and configuration.
**What it identifies**
* The space.vars.object’s schema
* Field definitions
* Relationship definitions
* Configuration type (Standard or Workflow)
**What it’s used for**
* Retrieving or describing space.vars.object schemas
* Determining which fields and relationships exist
* Applying validation rules to space.vars.entities
* Driving configuration-dependent behavior in APIs and space.vars.automations
**Key characteristics**
* **Schema-level**: identifies the structure, not the data
* **Stable**: does not change if the space.vars.object is renamed
* **System-generated:** typically represented as a UUID-style identifier
#### What Is A `record_id` ?
A `record_id` uniquely identifies a single space.vars.entity instance that belongs to an space.vars.object.
**What it identifies**
* One specific data space.vars.entity (for example, a single policy, ticket, or claim)
* The stored field values for that space.vars.entity
* References to related space.vars.entities
**What it’s used for**
* Creating, retrieving, updating, or deleting space.vars.entities
* Linking space.vars.entities through relationships
* Displaying data in timelines, dashboards, and reports
* Triggering space.vars.automations based on space.vars.entity-level events
**Key characteristics**
* **Instance-level**: it identifies data, not structure
* **Stable**: it does not change if field values or display names change
The platform needs stable, unambiguous references to both the schema (`custom_object_id`) and the specific data instance (`record_id`) in order to operate reliably across APIs, relationships, space.vars.automations, and space.vars.timelines.
### API-Facing Identifiers
In addition to system-generated IDs, space.vars.Kizen\_company\_name exposes API-facing identifiers. In API requests, space.vars.objects are referenced by API name.
These include:
* **Object API names** (for example, `deals`, `policies`)
* **Field API names** used in API payloads (for example, `email`, `name`)
API-facing identifiers:
* Are commonly used in API requests, space.vars.automations, and imports
* Allow space.vars.entities to be located without knowing internal IDs
* Resolve to system-generated identifiers internally
These API-facing identifiers resolve to system-generated IDs internally to ensure consistency and data integrity.
***
## Object Lifecycle
The space.vars.object lifecycle governs how a space.vars.object’s schema is created, evolved, and eventually retired. This lifecycle affects how space.vars.entities are validated and interpreted, but it does not directly manipulate stored data.
* **Object created → schema defined:** Creating an space.vars.object establishes a new schema, including its fields, relationships, configuration type (Standard or Workflow), and validation rules. At this stage, no space.vars.entities exist, only the structure they will conform to.
* **Schema modified → validation rules updated:** Changes to an space.vars.object—such as adding fields, updating required rules, or modifying relationships—updates the schema that governs future space.vars.entity writes. These changes affect how new or updated space.vars.entities are validated but do not automatically alter existing stored values.
* **Object deleted → schema removed:** Deleting an space.vars.object permanently removes the space.vars.object schema and deletes all associated Records. This cannot be undone.
Schema changes apply uniformly across all space.vars.entities for an space.vars.object. Field types are immutable, and existing field values are not changed unless a space.vars.entity is explicitly updated.
{% hint style="info" %}
**Note:** An space.vars.object cannot be deleted if it contains unarchived records. If unarchived space.vars.entities exist, the delete request returns a `400` error and the deletion does not proceed. Archive all space.vars.entities before attempting to delete the space.vars.object.
{% endhint %}
***
## Data Structure
Every space.vars.object is composed of three core elements: fields, relationships, and space.vars.entities. Together, these define both the structure of the data and how data behaves across the system.
space.vars.fields define the schema of an space.vars.object. They determine what data can be stored on space.vars.entities and how that data is validated and used across the platform.
Fields specify:
* The type of data (text, number, date, select, relationship, etc.)
* Whether the data is required, read-only, or required only in specific contexts
* How the data participates in space.vars.automations, reporting, integrations, and UI behavior
space.vars.fields belong to the space.vars.object, not to individual space.vars.entities. space.vars.objects support dynamic, business-defined schemas, allowing each organization to extend its data model without requiring code changes.
Each newly created space.vars.object includes several system fields that cannot be removed, including:
* \