Global Search

One search box for your entire book. Global Search queries 12 entity types in parallel — transactions, invoices, bills, journal entries, customers, vendors, ledgers, products, variants, emails, purchase orders, and shipments — and returns everything in a single flat, newest-first table. Type a name or number, paste an exact dollar amount, or flip on Natural Language mode and ask a plain-English question. Use it as the fastest way to jump straight to any record's drawer or its pre-filtered list page.

Key capabilities

• 12 entity types searched at once: products, variants, customers, vendors, transactions, invoices, bills, journal entries, ledgers, emails, purchase orders, shipments
• Text matching is case-insensitive substring across each entity's name, number, description, email, SKU, tracking, and subject fields
• Amount search: typing a dollar value (e.g. $1,250 or 5.00) matches numeric fields exactly, including negatives
• Relevance ranking per type: exact match first, then prefix match, then everything else, finally newest-first
• Entity-type filter to scope results to a single type (e.g. only invoices)
• Date-range filter that bounds results by creation date (ISO YYYY-MM-DD)
• Void invoices and deleted or archived records are excluded automatically
• Flat results table with Description, Type, Amount, Date, and Status columns
• Click-through navigation: detail-backed types open a drawer; the rest deep-link to a pre-filtered list page
• Natural Language mode: an AI panel translates a plain-English question into interpreted results with relevance scores
• Reachable from the sidebar (Search) or the Cmd+K command bar's "View all in Search"

How it works

When you submit a query, DayZero parses it once — every term is treated as text, and if it also parses as a dollar amount it is used for numeric matching. The same query then fans out to all 12 entity searches in parallel (or one, if you set a type filter), and each result set is ranked before being merged into the table.

flowchart TD
  q["Search query"] --> parse["Parse: text + amount to cents"]
  parse --> mode{"Natural Language on?"}
  mode -->|"No"| fan["Fan out to 12 entity searches"]
  mode -->|"Yes"| ai["AI interprets query"]
  fan --> filt["Apply type / date filters"]
  filt --> rank["Rank: exact > prefix > newest"]
  rank --> table["Flat results table"]
  ai --> panel["AI results panel (scored)"]

How to use it

1. Open Search from the sidebar, or press Cmd+K and choose View all in Search.
2. Type a term — results refresh automatically after a short (400ms) debounce, newest first.
3. Enter a dollar amount such as $150.00 to find records with that exact value.
4. Use the All Types dropdown to narrow to a single entity type (e.g. Invoices).
5. Set a Date range to bound results to a period.
6. Toggle Natural Language and press Enter to ask a question like "show me unpaid invoices over $500".
7. Click any row to open it: transactions, invoices, bills, journal entries, credit memos, and vendor credits open a detail drawer; other types jump to their list page with the term pre-filled.

Pro tips

• Dollar search matches the absolute value, so $150.00 finds both a +$150.00 deposit and a -$150.00 payment — handy when you only remember the amount.
• Amount matching is exact, not "greater than": search the precise total. For ranges or fuzzy questions, use Natural Language mode instead.
• Add a date range when a common word (a vendor name, "payment") returns too many rows — it bounds results by when the record was created.
• Set the type filter when you know what you're after; a single-type search returns more of that type instead of a handful from each.
• Use structured search for exact numbers, invoice numbers, and SKUs; use Natural Language for intent-based questions ("overdue invoices from Acme").
• Void invoices never appear — if an invoice is "missing," check whether it was voided.

In-depth guide

Searchable entity types and fields

Each entity type matches on a specific set of fields. Fields marked with * are numeric and respond to dollar-amount queries.

The type-filter dropdown may also list a couple of detail-only types (credit memos, vendor credits) that the cross-entity search itself does not scan; those types still open from their own list pages.

Query parsing: text and amount

Every query is parsed two ways at once:

• Text: a case-insensitive substring match, with special characters escaped so they match literally.
• Amount: the term is normalized as a possible amount — leading $ and thousands separators (,) are stripped and the remainder is parsed as a dollar value.
• If it parses as a number, numeric fields match on absolute value, so the stored sign doesn't matter.
• If it doesn't parse as a number, no amount conditions are added and the query is text-only.

Ranking and result shape

• Within each entity type, rows are ordered by a relevance tier: exact (lowercased) match on the primary field first, prefix match second, all other matches third — then by creation date descending.
• DayZero flattens every type into one table and re-sorts the combined rows newest-first by creation date.
• Each search returns up to a per-type limit — the Search page requests 25 per type.

Filters and exclusions

• The optional entity-type filter restricts the search to one type and returns only that group.
• The date range bounds results by creation date using ISO YYYY-MM-DD bounds.
• Deleted and archived records are filtered out everywhere, and voided invoices are always excluded.

Natural Language mode

Toggling Natural Language and pressing Enter sends your question to an AI assistant that returns:

• An interpreted query — how it understood you.
• A list of scored results, each with an entity type, title, optional subtitle, and a 0–1 relevance score, rendered as insight cards in a side panel.

This mode is best for intent ("unpaid invoices from last month") rather than exact lookups — for precise amounts or IDs, the structured search above is faster and deterministic.

Performance and edge cases

• All 12 entity searches run concurrently; if one fails it is treated as an empty result rather than failing the whole request, so a single bad query never blanks the page.
• Results are cached briefly to keep typing responsive.
• An unknown entity-type value returns an empty result set with an error note rather than failing.

Start free and find anything in your books in seconds.