Create and update entities from Spark

Jake Sawyer

Updated October 22, 2026 17:30

Spark can create and update Productboard entities directly from a conversation. Type a plain-language request. Depending on the conversation's mode, Spark either shows the proposed changes for you to confirm or applies them straight away. You can create or update a single entity, or handle up to 1,000 in one turn. If a change isn't what you wanted, you can revert it from the chat.

Note: Spark can also answer questions about entity change history. Ask what changed on a feature, when a status transition happened, or who made a specific update. See View an item’s history for details.

Tip: You can also start from the Create button in the Global header. Describe what you want in the Create with Spark input, and the new entity opens with a Spark chat attached. See Create new items quickly for details.

Supported entity types

Spark can create and update the following entity types:

Feature	Subfeature	Product
Component	Initiative	Objective
Key result	Release	Release group

Supported fields

During both entity creation and editing, Spark can manipulate default and custom fields, including:

Name (required for all entity types)
Status
Owner
Description
Start date and end date
Custom fields (including text, number, date, single-select, multi-select, and member fields)
Health update (currently can only create updates, not edit or delete)

During entity creation, if you don't specify a field, Spark leaves it blank (except for Name, you need one of those). You can set blank fields later from the entity's sidebar or by asking Spark to update it.

When asking Spark to work with fields, you should refer to them using their display names.

Example: "Set the owner of the Mobile redesign initiative to Alex."

Managing relationships between entities

Spark can read and edit the connections between entities in your workspace. You can add or remove relationships using plain-language requests. In Manual mode, Spark confirms all changes before committing them.

Spark supports three types of entity relationships:

Parent/child hierarchy: Places one entity under another in the product hierarchy (for example, a feature under a component, or a subfeature under a feature).
Links: Associates two entities without implying hierarchy (for example, linking a feature to an initiative, an objective, or a release).
Dependencies: Marks an entity as being dependent on another. Dependencies are only available between features, subfeatures, and initiatives.

Note: Spark only supports relationships that Productboard allows. Unsupported combinations (like trying to make an initiative the child of a component) appear as Blocked in the preview.

To add a relationship, describe the entities and the connection you want to create. Spark identifies the relevant entities and commits the change. In Manual mode, it shows a confirmation preview first and waits for you to confirm.

Example: "Link the Dark mode feature to the Mobile redesign initiative."

To remove a relationship, ask Spark to unlink or disconnect the entities. In Manual mode, Spark shows a confirmation preview before making any changes.

Example: "Remove the link between the SSO feature and the Q2 release."

Note: Spark can also link customer feedback to products, components, features, and subfeatures as insights. It can't move or remove existing insight links. See Link feedback to your product hierarchy with Spark for details.

Managing portal cards

Spark can read and edit the portal card for any feature in context. You don't need to open the portal or the feature's sidebar first. Spark can:

Read a card: Report the card's public name, public description, and every location it's posted to (portal, tab, and section).
Create a card: Draft customer-facing copy for a feature that doesn't have a card yet, based on the feature's spec and description.
Update a card: Rewrite the public name and public description of an existing card.
Publish, move, or unpublish a card: Post a card to a portal, move it to another tab or section, or remove it from a location.

You always choose the portal, tab, and section. Spark doesn't pick a location on its own. Before Spark writes any card copy, it shows the proposed public name and description in the confirmation preview for you to review.

Example: "Draft a portal card for the Dark mode feature from its spec, then publish it to the Customer portal under Planned > Settings."

Note: When Spark places a card in a new tab or section, it adds the card without a set position. To reorder cards within a section, drag and drop them in the portal. See Getting started with portals for details.

Spark can't upload or change card images, post portal card updates, or create new portals. Use the portal's internal view for these tasks.

Choosing Auto-accept or Manual mode

Each Spark conversation runs in one of two modes. The current mode is always visible in the Spark chat, and you can switch modes at any point in the conversation.

Manual: Spark shows a confirmation preview for every change and waits for you to confirm before committing.
Auto-accept: Spark makes entity, document, board, skill, and feedback changes straight away. It shows what it did on a review card in the chat.

To switch modes, use the mode setting in the Spark chat or press Shift+Tab. New conversations start in the mode you used last.

Note: In Auto-accept mode, Spark still asks before acting on a request that isn't clear.

In Auto-accept mode, Spark also applies document edits directly to the document. The chat shows an expandable before-and-after view for each block Spark edited. To undo a document edit, open the document's context menu and select Version history.

If an entity change isn't what you wanted, you can revert it in either mode.

How the confirmation preview works

In Manual mode, Spark shows a preview card listing every proposed operation before committing any changes. Each row shows one of two states:

Ready: the operation is valid and will proceed on confirmation.
Blocked: the operation can't proceed. Spark explains the reason, such as a missing required field, an unrecognized field name, or insufficient access.

For large batches, the preview splits into pages so you don't have to scroll through every row.

To accept the changes, reply to confirm in the conversation. Spark commits all ready operations. To reject, tell Spark to cancel or adjust your request.

Note: In Manual mode, Spark always shows the preview before committing. To skip the confirmation step, switch the conversation to Auto-accept mode.

Creating or updating multiple entities at once

You can create or update up to 1,000 entities in a single turn. List them in your request, attach a file with the details, or ask Spark to find and update a group based on criteria. If a request goes over the limit, Spark tells you.

Each entity appears as a separate row in the preview card. Blocked rows don't commit, but ready rows in the same batch do.

Example: "Create three key results for the Q3 growth objective: increase trial conversion to 30%, reduce churn below 5%, and grow NPS to 45."

Running chained workflows

Spark can combine a read step with a write step in a single request. This lets you find entities that match a condition and update them in one turn.

Spark first queries your workspace for matching entities, then presents a preview of the proposed updates. In Manual mode, you confirm before anything is committed.

Example: "Find all features without an owner and assign them to me."

Reverting entity changes

If Spark makes an entity change you didn't want, you can undo it from the chat. Reverting works in both Auto-accept and Manual modes.

To revert a change, do one of the following:

Type "revert this" in the chat, or...
Click Restore previous values from this reply on the review card. This undoes everything Spark did to entities in that turn.

Revert covers entity updates and link or unlink operations. Each revert appears in the entity's history. See View an item’s history for details.

Note: Spark can't revert a value that changed again after its update. Revert also doesn't cover document edits. Use the document's version history for those instead.

Permissions and access

You must have editor access to an entity to create or update it. Spark checks your permissions before presenting the preview.

If you don't have editor access, the affected row appears as Blocked in the preview with the message: "You need editor access to this entity. Check with your workspace admin."

Blocked rows don't commit. Other rows in the same batch that you do have access to will still proceed.

Example prompts

Here are some prompts to get you started.

Creating entities:

"Create a feature called Dark mode under the Settings component."
"Create an initiative called Mobile redesign with status In progress and owner Sarah."
"Create three key results for the Q3 growth objective."
"Create a release called 2.4 with a start date of July 1."

Tip: Before you create a new item, ask Spark to check whether something similar already exists. For example: "Is there already a feature similar to Dark mode?" Spark searches by meaning as well as keywords, so it can find likely duplicates that use different names.

Updating entities:

"Update the status of the Onboarding flow feature to In review."
"Set the owner of the Mobile redesign initiative to Alex."
"Add a description to the Dark mode feature: Allow users to switch between light and dark themes."
"Set the end date of the Q3 growth objective to September 30."
"Mark the Mobile redesign initiative as At risk. Add a comment: delayed by platform migration."

Managing relationships:

"Link the Dark mode feature to the Mobile redesign initiative."
"Set the Analytics dashboard as a child of the Reporting component."
"Remove the link between the SSO feature and the Q2 release."
"Mark the Authentication feature as blocking the SSO subfeature."
"Show me all features linked to the Q3 growth objective."

Managing portal cards:

"What does the portal card for the SSO feature currently say?"
"Create a portal card for the Dark mode feature using its spec."
"Rewrite the public description of the Analytics dashboard card for a non-technical audience."
"Move the SSO card from the Planned tab to the Launched tab in the Customer portal."
"Remove the Audit log card from the Enterprise portal."

Multi-entity and chained operations:

"Find all features without an owner and assign them to me."
"Update the status of all features in the Onboarding component to In review."
"Create five subfeatures under the Authentication feature: password reset, SSO, MFA, session management, and audit log."