Skip to main content
Manual entry is the right tool for items that aren’t ingested: spreadsheet-sourced data with no API behind it, a quick correction to a single value, or a one-time load while you wait to wire up the ingestion. For anything ongoing, use Ingestion.

​
When to use manual entry

Use manual entry for unique, non-recurring cases that can’t be synced with an API.
  • Importing from a spreadsheet: For bulk data from a spreadsheet with no API behind it, use CSV import.
  • One-off item: For a one-off item that isn’t tracked anywhere else, add through the UI.
  • Editing: To fix a wrong value on a single item, edit through the UI.
Don’t use manual entry for recurring data from any system with an API or data you need refreshed automatically. Instead, use Ingestion.
Any value you set manually is overwritten on the next sync unless you pin the field to keep a manual value. See Multiple sources for one item type

​
Add an item

  1. Open the item type in the Databases tab.
  2. Click Add Item->Create item manually.
  3. In the Create Item popup, fill out the fields.
Create Item dialog with serial number and name required, plus optional fields like RAM, disk size, and OS version

The Create Item dialog for a Computer item type

The key and name fields are required. All other fields are optional unless you’re creating an edge-type relationship (which requires both endpoint fields). If you enter a key that already exists, creation fails. If you need to update by key, use edit on the existing item or update by CSV import.

​
Edit field values

Item detail view for a MacbookPro15 item showing its key and name fields and source

An item detail view

  1. Click any item to open its detail view.
  2. Click any field to edit inline, or click the edit (pencil) icon to edit all fields.
  3. Changes write through immediately. Every edit is recorded in the item’s history with author, timestamp, and the previous value. For more on item history, see Administration.
Item edit view for MacbookPro15 with editable name field and Save and Cancel actions

Editing an item's fields inline

​
Edits and ingestion

If a field is fed by an ingestion config, a manual edit gets overwritten on the next sync that maps to that field. To make a manual edit persist:
  • Remove the mapping for that field on the ingestion config, or
  • Lower the ingestion mapping’s priority so manual entry wins, or
  • Update the value at the source instead of in Serval.
Fields that no ingestion maps to are safe to edit. Provenance in the item’s history shows whether each value came from manual entry or from a specific ingestion run.

​
Bulk import from CSV

Use CSV import for one-shot loads from a spreadsheet, vendor export, or migration from another system.

​
CSV format

  • The first row is a header row.
  • Map a column to the item type’s key field. This is required for a successful import.
  • All other mapped columns are optional.
  • Columns you don’t map are ignored.
  • Column order doesn’t matter.

​
Importing

  1. Open the item type in Databases.
  2. Click Add Item->Import from CSV.
  3. Upload the file. Serval validates the header row against the item type’s fields.
  4. Review the preview. Serval shows how many rows will be inserted, how many will update existing items (matched by key), and any parse errors per row.
  5. Confirm.
Import assets from CSV dialog with a Choose CSV file button and Upload and analyze action

The CSV import dialog

Rows with parse errors are skipped, not retried. Fix them in the source CSV and re-import.
Matching by key means re-importing a corrected row updates the right item, not a duplicate

​
Key collisions and updates

Import deduplicates by the key field. A row whose key matches an existing item updates that item’s fields with the values in the CSV. Fields not present in the CSV are left unchanged.

​
What’s next

Connect a recurring source

Replace manual loads with an ingestion that keeps the data fresh.

Browse and filter

Verify the import landed correctly and start querying.

Track every change

Provenance shows whether each value came from manual entry, CSV, or a specific ingestion run.