Sliick Docs: Complete User Guide

Version: Updated for Sliick Docs v1.2.0 (04tRE000002nmyPYAQ), live on the Salesforce AppExchange. The 1.2.0 release layers on top of the v1.0 Captivating feature surface and adds Microsoft Word .docx output, an opt-in compliance audit log with SHA-256 fingerprinted merge-value snapshots, per-template retention policies with a nightly sweep, the list-view mass action, barcodes (Code 128) and QR codes (ISO 18004) as standalone blocks, image-block merge-field source for per-record letterheads and logos, an admin analytics dashboard, the Generations tab (renamed from Jobs), and a round of editor polish.

Sliick Docs brings native, versioned document generation to your Salesforce org. Admins design templates in a WYSIWYG editor and publish them as immutable releases; business users generate the resulting PDF or Microsoft Word file in one click from any record page; list-view mass actions and Flows generate them in bulk; and the auto-email pipeline routes the finished file to the right recipients automatically. This guide is the complete reference for everyone who touches the product.

Guide overview

1. What is Sliick Docs?
2. Quick start: generate a document from a record
3. Install, permission sets, and the org-wide theme
4. Authoring templates
5. Templates, Bundles, and Batches: the three units of work
6. Bulk generation with Doc Batches
7. List-view mass action
8. Multi-template Doc Bundles
9. Auto-email after generation
10. Flow integration: three Flow actions
11. Microsoft Word (.docx) output
12. Compliance: audit log and retention policies
13. Analytics dashboard
14. Template and Bundle portability: Export and Import
15. Security and permissions
16. Troubleshooting and reference

What is Sliick Docs?

Sliick Docs is a 100% native Salesforce document-generation app. Everything runs inside your org. PDF rendering uses the native Salesforce PDF engine; Microsoft Word .docx files are assembled in Apex via Compression.ZipWriter. No document content ever leaves your boundary or transits a third-party service.

Key concepts:

• Template: one per logical document type (Account Summary, Quote Cover Letter, Work Order). Admins edit a template; end users generate from it. Each template can be configured to allow PDF output, Word output, or both.
• Draft and Release: while a template is being edited it lives as a draft. Publishing creates an immutable Release: a frozen snapshot the runtime renders from. Drafts can change freely; releases never do.
• Active Release: the release currently serving end users. Switching versions or rolling back is a single, fully audited change.
• Bundle: a named, ordered collection of templates rendered together against a single record as one combined PDF. Bundles publish to immutable releases too.
• Batch: a bulk run that produces many files from one template (or one bundle) against many records.
• Generation: the audit row for one rendered file (the Job__c object, surfaced via the Generations tab). Tracks who generated what, in which format, from which template release, against which record, and the email outcome if auto-email is enabled.
• Base object: every template (and bundle) is anchored to a single Salesforce object. Merge fields and runtime data come from records of that object.

There are four ways to generate a document: from a record page (one click), from a list view (tick records and click a mass-action button), from the Doc Batches console (admin bulk), or from a Flow (record-triggered, scheduled, or screen). All four share the same rendering engine, so what your admin sees in proof is what every recipient gets.

Quick start: generate a document from a record

The fastest path from a fresh install to a generated file, assuming an admin has already done section 3 below.

1. Open a Salesforce record on an object that has a published Sliick Docs template (Account, Opportunity, your custom object).
2. Find the Sliick Docs Generator component on the record page.
3. Pick a template from the list (only templates with an active release for this object appear).
4. Click Generate PDF or Generate Word depending on what the template allows. If only one format is enabled you see a single button; if both are enabled you see a split button and pick at runtime.
5. The file appears in the Files related list. Click to open or download.

That is the end-user experience. Everything else in this guide is about giving admins the tools to design those templates well and to scale generation up to bulk, automation, multi-template bundles, and compliance-grade audit.

Install, permission sets, and the org-wide theme

Install the package

Install from the Sliick Docs AppExchange listing.

When prompted, install for All Users (or Admins Only if you want a controlled rollout, then assign the relevant permission set per user).

Permission sets

Three permission sets ship with the package. Assign each user the one (or two) that match their role.

Assign from Setup > Users > Permission Sets.

Tip: in production, treat Sliick_Docs_Admin as a privileged role for a small group of template authors. End users only ever need Sliick_Docs_User. The running user of every Sliick Docs Flow needs Sliick_Docs_Automation.

Set the org-wide theme

Open the Sliick Docs app from the App Launcher and click Settings. The Brand & theme panel controls the palette every template inherits.

Theme changes take effect the next time a template is published. Existing releases keep the theme they were published with, so historical PDFs remain reproducible even after a rebrand.

Open the Template Library

Open the App Launcher and select Sliick Docs. The default landing tab is the Template Library. The other top-level tabs you will use are Doc Bundles, Doc Batches, Generations (formerly Jobs), Analytics, and Settings.

The Template Library’s right-rail help pane carries a Starter templates card linking to a gallery of six ready-to-import templates - Sales Proposal (Opportunity), Account Statement, Welcome Letter (Contact), Lead Follow-up, Case Summary, and Order Confirmation. All six are built on standard Sales and Service objects with no custom fields, so they import cleanly into any sandbox.

Authoring templates

Create a template

A template is anchored to a single base SObject (for example Account, Opportunity, or any custom object). Every document the template generates is for one record of that object.

1. Open the Template Library and click New template.
2. Give the template a clear name (this becomes part of the generated PDF file name). Names are unique across the org, case-insensitive.
3. Choose the Base Object the template will run against.
4. Click Create. Sliick Docs creates the template and an initial draft, then opens the editor on that draft.

Note: the base object cannot be changed after creation. If you need a different base object, create a new template.

Editor anatomy

The Template Editor has four regions:

• Top bar: Save, Generate proof, Preview, Publish, history drawer, test record picker.
• Left rail: Blocks palette and Merge fields tab.
• Designer canvas: the page being authored.
• Right rail: Page settings and the Properties / Block style panels for the selected block.

A pinned inline formatting toolbar sits above the canvas whenever a styleable block is selected.

Pick a test record

Every draft needs a test record so proofing can render against real data.

1. In the top bar, click the Test record picker.
2. Pick any record on the base object. Use a record with realistic data including any parent lookups or child collections you reference.

The selection is saved with the template and reused across draft sessions. Picking a test record is a prerequisite for publishing.

Block reference

Drag blocks from the Blocks tab on the left rail, or click + Add block inside any container. Every block is selectable; the right rail switches to its Properties and Block style panels on select.

Block-level styling

Every styleable block exposes a Block style section in the right rail. The controls render live in the canvas so what you see matches what the PDF will contain.

Theme references (brand.primary, theme.headingColor) resolve at compile time, so an org-wide theme change repaints every block using those references the next time the template is published. Hex codes are literal one-offs that do not track theme changes.

Inline formatting toolbar

When you select a text, heading, table cell, callout, or other styleable block, a toolbar pins itself above the canvas.

The per-run controls work in two modes: highlight a range first then click a control (Selection mode), or with just a caret click a control to arm it (Toggle-then-type mode). Active / Mixed / Off states reflect the selection: a Mixed underline button means part of the selection is underlined and part is not.

Merge fields

Merge fields are first-class objects in Sliick Docs. They are stored as structured chips inside text runs, not as plain text placeholders, so they cannot be accidentally broken.

To insert a merge field:

1. Click into a Text, Heading, or table cell block.
2. Open the Merge fields tab on the left rail (or type {{ to open the autocomplete).
3. Search by label or API name and click the field to insert it.

Scope of merge fields

• Root scalar fields on the base object.
• Parent lookup fields up to five hops (for example Account.Owner.Profile.UserType.Name). Works at root scope and inside Repeat scope.
• Child collections rendered via Repeat for each blocks (one-hop child relationships, no nested repeats).
• Conditional visibility via Show if (cond) blocks (see grammar below).
• Aggregate functions over child relationships: SUM, COUNT, AVG, MIN, MAX, with an optional Format.
• Image merge fields: any ContentVersion / URL field can be rendered as an inline image (toggle in the chip popover) or as a standalone Image block via the block’s Source -> Merge field toggle.
• Hyperlinks: text or merge-field chips can be wrapped in <a href>; merge-field placeholders are allowed inside the URL (https://salesforce.com/{{Account.Id}}).
• Barcodes and QR codes: standalone blocks bound to any merge field; resolved value gets encoded inline by a pure-Apex encoder at PDF time.

Field-level security

Sliick Docs always honours your Salesforce permissions. When an admin browses for merge fields, they only see fields they themselves can read - so two different admins may see different field lists depending on their access. If a field you expect to see is missing, ask your Salesforce admin to check your profile or permission sets.

Format dropdown

Every scalar merge-field chip carries a Format dropdown alongside the fallback input. The format choice applies at PDF render time using the running user’s locale; the chip’s stored value is untouched.

Fallback text

The same chip popover offers a Fallback text input. If the resolved value is blank at runtime, the fallback renders instead. Useful for Account.Phone with a fallback of (no phone on file).

Image merge fields

To merge a Salesforce ContentVersion or URL field as a dynamic image inline within text:

1. Insert the merge field chip as usual.
2. Click the chip to open its popover.
3. Toggle Render as image. Width and height inputs appear.

At runtime the chip resolves to an <img> tag using the field’s URL or the latest ContentVersion’s download URL. Image merge fields work the same way inside Repeat scope: each iteration resolves to its own image.

Image block with merge-field source

For per-record letterheads, signatory logos, or hero images that appear as a standalone block (not inline within a text run), use the Image block’s Source toggle:

• Static file (default) - the same image on every doc, picked from a Salesforce File.
• Merge field - the image varies per record. Bind any field that resolves to a ContentVersion Id.

The merge-field source emits the same <img data-merge-field> placeholder that the inline image chip uses, so per-record letterheads “just work” against any ContentVersion-ID-resolving field. Pair with auto-email and a letterhead field on Account to send branded statements without one-off-per-account templates.

Barcodes and QR codes

Sliick Docs ships dedicated Barcode (Code 128) and QR Code (ISO 18004) blocks in the Block Kind Picker. To add one:

1. Click + Add block and pick Barcode or QR Code.
2. In the right rail, bind the block to any merge field (the field whose value will be encoded).
3. Set width, height, and alignment.

The encoder is pure Apex - no external services, no static images, no callouts. At PDF generation the resolved merge-field value gets encoded inline as CSS-bars HTML, which renders reliably through the native PDF engine with no heap cost. Both block types respect Repeat scope, so per-row barcodes for shipping labels or asset tags are a one-line change.

Barcodes and QR codes are PDF-only - the validator rejects a template that enables Word output when either block is present. Authors typically split templates: the PDF-only variant carries the barcode, the Word-friendly variant doesn’t.

Hyperlinks

Wrap text or merge-field chips in <a href> via the link affordance in the inline toolbar. URLs accept merge-field placeholder tokens, for example https://help.example.com/account/{{Account.Id}}. The merge fields inside the URL resolve per record.

Lists

Bulleted and numbered lists are first-class blocks. Each list item is a text run that supports merge field chips and inline formatting.

Conditional content (Show if)

A Show if block conditionally renders its children based on parent-record data. Expressions are parsed at save time, so any syntax errors surface in the right rail as plain-English messages while you author.

Operators: =, !=, >, >=, <, <=, contains (case-insensitive substring). Literals: single-quoted strings, decimals (including negative), true, false, null.

Repeating sections

A Repeat for each block loops over a child relationship of the base object. The block’s children render once per row (one row per Opportunity Line Item, one row per Contact, and so on).

• Source relationship: pick from the dropdown of available child relationships. The list only shows relationships you have access to.
• Filter (optional): narrow the rows that render, for example Opportunities.StageName != 'Closed Lost'.
• Inside a Repeat block, the Merge fields tab flips to show the child object’s fields. Insert chips like {{Opportunities.Amount}}; they resolve per row at runtime.
• Five-hop parent lookups also work inside Repeat blocks, for example Opportunities.Account.Owner.Profile.Name.
• Nested Repeat blocks aren’t supported in v1.0.

Signatures

A signature block renders a 2+ signer area with top-bordered lines and merge-field signer labels (for example Account.Name for the customer line, Account.Owner.Name for the rep line). Add or remove signers in the right rail; minimum two.

Watermarks

In the right rail Page settings, the Watermark controls let you stamp every page of the generated PDF with text. Set the text, a colour, an opacity slider, and a font size; the editor preview matches what the PDF will contain. Theme references and merge-field chips are not supported inside the watermark text (string only). Use this for DRAFT, CONFIDENTIAL, copyright lines, or document-classification labels.

Watermarks are PDF-only. Templates with a watermark cannot enable Word output; the validator surfaces this at save time. Admins typically remove watermarks from any template that needs an editable-Word-draft workflow.

Validation, proof, and the Ready state

Sliick Docs validates your template every time you save (and again when you proof or publish). It checks that every merge field, theme reference, and inline expression still resolves and that block-level styling is within bounds, so problems surface before generation rather than during.

The right rail shows the current state (Valid, Warnings, Errors) with a plain-English summary you can act on. Unresolved merge fields are treated as errors so they never silently render as blanks at runtime. Preview, Proof, and Publish are hard-stopped when validation has open issues - broken templates cannot leak past the editor. Multi-line toast formatting renders each validation message on its own line instead of running them together.

To generate a proof:

1. Save your changes.
2. Click Generate proof in the top bar. For templates that allow both PDF and Word, the proof modal generates both formats so you can review each output path.
3. Review the resulting file(s). Generated proofs are saved to Salesforce Files with the file name <Template Name> - v<Version Number> - Proof - <Record Id>.<ext>.

A version becomes Ready when validation is Valid and the version has been proofed against its test record at the current saved contract. Saving after proofing drops the version back to Draft until you re-proof.

Publishing

Publishing freezes your current draft into a new, immutable release and atomically makes it the active version. Releases never change after publish, so a document generated today will look identical when re-generated next year.

1. From the editor, click Publish in the top bar. (The button appears once the version is Ready.)
2. Confirm. Sliick Docs creates the release, snapshots the theme alongside it, and switches end users onto the new version - all in one step.
3. The editor goes read-only. A + Create draft button replaces Publish when you’re ready to iterate again.

To roll back, point the template at a prior release (or clear it to take generation offline for that template). Past releases are preserved for audit.

Templates, Bundles, and Batches: the three units of work

It is worth naming the distinction up front.

• Template is the unit of authoring. One template renders one PDF for one record at a time.
• Bundle is the unit of composition. One bundle stitches several templates together into a single combined PDF for one record. Bundles publish to immutable releases too.
• Batch is the unit of bulk. One batch runs one template (or one bundle) against many records. Each batch has its own status (Queued, Running, Merging, Succeeded, Partial Success, Failed, Aborted) and tracks one job per record.

Behind the scenes all three follow the same path: load the record, evaluate any conditional or repeating sections, substitute merge fields, render using the native Salesforce PDF engine, save to Salesforce Files. The difference is who initiates and how many records are covered.

Bulk generation with Doc Batches

The Doc Batches tab is where admins submit and monitor bulk runs.

Submit a new batch

1. Click New batch.
2. Pick a template (only templates with a published release appear) or a bundle.
3. Pick a source:
   • By filter: type a SOQL WHERE clause (or leave blank to target every record of the base object).
   • By report: pick a tabular Salesforce report (up to 2,000 rows).
   • By record IDs: paste a list of up to 2,000 record IDs (also available from the Flow action).
4. Pick a batch size (1 to 200, default 1).
5. Pick an output mode:
   • Individual (default): one PDF per record, attached to that record via ContentDocumentLink.
   • Combined PDF only: one merged PDF attached to the batch row; no per-record files.
   • Both: one PDF per record plus a combined PDF.
6. (Optional) Pick an Output Format: PDF (default) or Word. Word batches require Individual mode.
7. Click Analyze.

The pre-flight verdict shows release readiness, record count vs the 50,000 cap, and (for Combined / Both) a combined-heap estimate. Combined-output batches with more than 50 records fail upfront in the analyzer with an actionable “Switch to Individual mode” message instead of silently exhausting the async heap mid-run.

Spot-check sample

From the verdict, click Preview sample to step through up to 5 sample records and see exactly how each will render. This catches merge-field problems before generating 500 PDFs.

Monitor

The batch monitor refreshes every 5 seconds. The header shows a status badge and progress bar; the per-record table updates as each record completes. While the run is in flight, Cancel is available and Sliick Docs stops the underlying job as soon as it can.

When the run terminates, the recent-batches sidebar updates and a Sliick Docs Batch notification is sent to whoever submitted it.

Download

• Individual / Both modes: Download all as ZIP is available on the monitor. Sync up to 50 records; asynchronous above (a notification fires when the ZIP is ready). Each batch also lists per-record files inline.
• Combined / Both modes: the combined PDF is on the batch row itself, available as a single download.

Retry failed

After a batch ends as Partial Success or Failed, expand the row and click Retry failed. If the template has been republished since the original run, Sliick Docs surfaces that in the confirmation dialog so you can decide whether to re-run against the original release or the new one. The new batch links back to the original so you can trace retry chains. Capped at 2,000 failed records per retry.

Limits worth knowing

List-view mass action

Admins can add a one-line custom list button (URL /flow/Generate_Sliick_Docs_From_List_View) to any object’s list views so end users can tick records and trigger a batch generation in one click - no Flow build, no admin involvement at runtime.

Add the button

1. Setup -> Object Manager -> pick the object (Account, Opportunity, Contact, Case, Lead, Order, or any custom object).
2. Buttons, Links, and Actions -> New Button or Link.
3. Display Type: List Button with Display Checkboxes (for Multi-Record Selection) ticked.
4. Behavior: Display in existing window with sidebar. Content Source: URL.
5. URL: /flow/Generate_Sliick_Docs_From_List_View.
6. Save, then add the button to the list view’s Search Layouts -> List View layout.

The same button URL works for every object - object type is derived automatically from the first selected record’s key prefix.

Use it

1. From any list view with the button installed, tick up to 200 records.
2. Click Generate Sliick Docs in the list-view button bar.
3. Pick a template that matches the object’s base object and an output format (PDF or Word).
4. Submit. The batch lands in the Doc Batches console with full status monitoring.

Multi-template Doc Bundles

A bundle is a named, versioned bundle of templates rendered together against one source record to produce a single combined PDF. A Sales Bundle might combine a cover letter, the actual quote, the terms and conditions, and an optional NDA addendum.

Create a bundle

1. Open the Doc Bundles tab.
2. Click New bundle.
3. Fill in the display name, base object API (every member template must share this base object), and an optional description.
4. Click Create.

Add templates to a bundle

1. On the bundle card, click + Add template.
2. Pick a template that shares the bundle’s base object. Templates already in the bundle are filtered out.
3. Set Required or Optional. Required = the bundle fails if the template is inaccessible. Optional = soft-skip and continue.
4. Click Add. The item appends to the end.

Reorder items with the up / down arrows on each row. Remove items with the trash icon.

Per-item inclusion expressions

Each bundle item can carry an optional inclusion expression (same grammar as the Show if block, for example Account.Industry = 'Technology'). The expression is frozen into the bundle release at publish and evaluated at runtime against the source record. Items that evaluate to false are silently skipped from the combined PDF.

Publish a bundle

Click Publish on the bundle card. Sliick Docs snapshots each member template’s current active release into the new bundle release. Once published, the bundle renders the same way every time, even if a member template is later republished.

Drift handling

Bundle releases are immutable by design. When a member template is republished after the bundle was published, the bundle does not auto-update. Instead:

• The bundle library card shows a yellow Members updated badge with a tooltip listing affected templates.
• A one-click Republish with current members action produces a fresh release that re-snapshots all current member releases.
• The retry-failed confirmation dialog on the Doc Batches console calls out drift in the same way.

Bundle runtime

Single-record bundle generation is available through the Generate Sliick Bundle Flow action (section 9). Bulk bundle generation is available through Generate Sliick Docs (Bulk) (pass the bundle instead of a template) or directly from the Doc Batches console.

Auto-email after generation

Configure email-on-success per template via six fields on the Template record.

When generation succeeds for a record (single or batch), Sliick Docs sends the email automatically. The subject and body come from your chosen Email Template (with full merge-field support against the source record); the generated PDF is attached.

Every record’s job carries an email audit trail:

Behaviour on failure: if generation succeeds but the email fails (for example the recipient field is blank), the document still counts as successfully generated and the file is saved. The Email Status field records the failure separately. The batch’s overall status rolls up: any failed email flips the batch to Partial Success even when every document generated cleanly.

Daily limit. Salesforce caps single-recipient emails at 5,000 per 24 hours, org-wide. A batch that would exceed the daily allotment is flagged in the pre-flight analyzer.

Flow integration: three Flow actions

Sliick Docs ships three Flow actions for use in Record-Triggered, Scheduled, and Screen Flows. All three are designed to never throw. Failures are returned cleanly as success=false plus an errorMessage, so your Flow can branch on the outcome rather than halting the whole transaction when something goes wrong.

Generate Sliick Doc (single record, synchronous)

Outputs: jobId, contentDocumentId (the saved file), success, errorMessage.

Generate Sliick Docs (Bulk) (asynchronous; returns the batch ID immediately)

Outputs: batchId, success, errorMessage.

One important Flow-authoring rule: pass your record collection to the bulk action once, not inside a Loop. Wrapping the bulk call in a Loop creates one batch per record instead of one batch for the whole set, which is almost never what you want.

Generate Sliick Bundle (single record, synchronous)

Outputs: jobId, contentDocumentId (the combined file), success, errorMessage.

Three common automation shapes this unlocks

1. Auto-on-state (Record-Triggered Flow): Opportunity entry condition IsClosed = TRUE → call Generate Sliick Doc with templateId + [Record].Id. A closeout PDF lands on every newly-closed Opportunity automatically. Pair with auto-email to email it to the customer too.
2. Recurring batch (Scheduled Flow): daily at 2am → Get Records (Accounts updated yesterday) → single call to Generate Sliick Docs (Bulk) with the resulting collection. Customers receive an overnight statement PDF.
3. User-driven bulk (Screen Flow): picker for template, picker for filter or report → Generate Sliick Docs (Bulk) → display the returned batch ID with a follow-up link to the Doc Batches tab so the user can monitor progress.

Microsoft Word (.docx) output

Sliick Docs generates either a PDF or a Microsoft Word .docx from the same editor state - one source of truth, two output paths. Word output uses Salesforce’s Compression.ZipWriter to assemble OOXML in pure Apex, so no external service is involved.

Enable Word output on a template

Two flags on the Template record control which formats end users see:

A validation rule rejects the both-off state - at least one format must be enabled. Enable both to give end users a split button at runtime.

When Word vs PDF

The data inside the document is identical between formats; only the output file type differs.

Where Word output works in v1.2

• Record-page Sliick Docs Generator (split button when both formats enabled)
• All three Flow invocables (optional outputFormat input)
• Doc Batches console + Bulk Flow invocable - Individual output mode only
• Single-record bundle generation
• List-view mass action
• Dual-format proof during authoring

Word output limitations in v1.2

• Combined / Both batch modes are PDF-only - use Individual mode for Word batches.
• Bundle Word uses the org default theme. Single-template Word honours per-template theme overrides correctly; bundle Word does not.
• Watermarks and barcodes are PDF-only - the validator rejects a template that enables Word output when either is present. Authors typically split into separate templates (one for the editable-Word workflow, one for the locked-PDF version).
• Templates published before v1.1 need a one-time re-publish to enable Word output (populates the new Editor_State_Snapshot__c field).

File-name pattern auto-swaps the extension

The per-template File name pattern doesn’t need an {{ext}} token. The extension swaps automatically based on which format was generated:

• Pattern {{Account.Name}} - Quote.pdf -> generated as Word becomes Acme Corp - Quote.docx.
• Pattern {{Account.Name}} - Quote.docx -> generated as PDF becomes Acme Corp - Quote.pdf.

Salesforce previews Word files natively, so generated .docx files render inline in the Files viewer alongside PDFs.

Compliance: audit log and retention policies

Two opt-in capabilities make Sliick Docs ready for regulated industries: a SHA-256-fingerprinted audit log of what got merged into each document, and a per-template retention sweep that hard-deletes aged artifacts.

Compliance audit log

Enable per template via the Audit Enabled checkbox (Template__c.Audit_Enabled__c). Once on:

• Every successful generation captures a SHA-256-fingerprinted snapshot of resolved merge values into a new Doc_Audit_Entry__c row - one per record per generation.
• The snapshot is capped at 10 KB with a …[truncated] marker; the pre-truncation payload digest is preserved separately, so post-truncation edits are detectable by recomputing the digest against the stored value.
• Writes route through a narrow without sharing audit service, so users cannot suppress or forge entries via permission-set holes.
• The Generations tab links each Generation to its audit entry.

Use this for contracts, regulated communications, NPC donation receipts, accreditation letters, or anything that needs a verifiable “this is what we sent and the captured values have not been altered through normal user paths” record. Note that the digest is integrity-grade, not adversarial-tamper-evident: Salesforce preserves the subscriber System Administrator’s authority over their own org data, so a privileged administrator with Modify All Data could in principle edit both the payload and the digest and the recomputed value would still match. For evidentiary-grade tamper evidence layer Field History Tracking on the audit object, or export digests periodically to a customer-controlled store outside the org.

Retention policies

Set a per-template auto-delete window via the Retention Days field (Template__c.Retention_Days__c). 0 means retain forever; anything else is a number of days the generated artifact lives in Salesforce Files before the sweep collects it.

The nightly Doc Retention Job does the work:

• Finds Generations whose template carries a retention window and whose artifact is older than the threshold.
• Hard-deletes the underlying ContentDocument.
• Stamps the Generation with Artifact_File_Id__c = null and Retention_Action__c = 'Deleted', so the audit trail survives even after the file is gone.

Two safety mechanisms:

• Hold from Deletion is a per-Generation checkbox (Job__c.Hold_From_Deletion__c). Tick it on a specific row to exempt it from the sweep - useful for files that have to survive an open audit window, legal hold, or dispute.
• The sweep only deletes Sliick-Docs-generated files. Other ContentDocuments on the record are untouched.

Schedule the sweep from Settings -> Schedule retention sweep. Pick a daily time and click Schedule.

Analytics dashboard

A new Analytics tab (admin-only) sources everything from existing generation history - no new tracking infrastructure to set up. The dashboard auto-refreshes every 5 minutes with a manual refresh available.

The failure category is computed by DocFailureCategoriser at the moment a Generation is marked Failed, so the dashboard does a cheap GROUP BY instead of materialising raw error strings. Failures generated before v1.1 ship as Other until they age out of the 30-day window (no historical backfill).

The dashboard is powered by Sliick-charts, a separate 2GP package in the same namespace that installs as a dependency of Sliick Docs. No extra configuration needed.

Template and Bundle portability: Export and Import

Templates and bundles are Salesforce records, not metadata, so Change Sets and SFDX deploy do not move them. The Library and the Bundles tab both ship Export and Import actions.

Export

• Template Library: every template card has a download icon. Clicking it downloads sliick_<TemplateName>_<YYYY-MM-DD>.sdt (Sliick Doc Template).
• Bundles tab: every bundle row has an Export link. The export includes the bundle header, items, and every member template by default so the target org has everything it needs.

Org-specific references (test record ID, auto-email recipient / CC / from-address / template IDs) are scrubbed automatically. The export envelope is schemaVersion 2, the current Sliick Doc Template format used by Export and Import. Old schemaVersion 1 files surface an actionable “re-export from a current org” message on import.

Import

1. Open the target org’s Template Library (or Bundles tab) with Sliick Docs installed and Sliick_Docs_Admin assigned.
2. Click Import Template (or Import Bundle).
3. Choose the .sdt file. Click Import.
4. A summary modal lists what was imported with any warnings (renamed-on-collision, unresolved merge fields, fields hidden by your permissions, unresolved bundle members).

What an imported template starts as

• Status: Draft. Imported templates never start as Active. Re-publish after picking a test record and re-validating.
• No active release. Releases are immutable runtime snapshots local to each org.
• Test record is unset.
• Auto-email is disabled. Recipient / CC / from-address / template IDs are org-specific Lookup values and are scrubbed on export.

Name collisions

If the target org already has a template with the same name, the import auto-renames to <Name> (Imported 1), then (Imported 2), and so on. The summary surfaces the rename so you can fix it from the Library. The same auto-rename runs on Create template when the requested name already exists: the new template lands as <Name> #<last 4 chars of Id> (e.g. Invoice #a1B2) and a “Template renamed” toast appears so authors immediately see what happened.

Starter templates

The Template Library’s right-rail help pane carries a Starter templates card linking to a gallery of six ready-to-import templates: Sales Proposal (Opportunity), Account Statement, Welcome Letter (Contact), Lead Follow-up, Case Summary, and Order Confirmation. All six are built on standard Sales and Service objects with no custom fields, so they import cleanly into any sandbox via the existing Import flow. Use them as a starting point or as worked examples of every feature in this guide.

Security and trust

Sliick Docs is built to a Salesforce-first security model and has passed the AppExchange security review. The short version for a security or compliance reviewer:

• Your data never leaves Salesforce. Documents are rendered by the native Salesforce PDF engine, inside your org. Word .docx files are assembled in Apex via Compression.ZipWriter. No external rendering service, no third-party endpoint, no Remote Site or Trusted Site is required.
• Your existing Salesforce permissions are enforced everywhere. Every read and write Sliick Docs performs runs with the user’s own sharing, profile, and field-level security. Two users will see only the data they’re already entitled to see, in the editor and in the generated documents.
• Published releases are frozen snapshots. Each Publish action creates an immutable release that the package treats as read-only: permission-set field-level security plus a write-guard trigger refuse edits and deletes through every Sliick path. A document generated today will look identical a year from now, even if the underlying template has been rewritten.
• Every generation is fully audited. Each file, single or bulk, is logged as a Generation with who ran it, when, in which format (PDF or Word), against which record, with which template release, the resulting file, and (when auto-email is on) every recipient address.
• SHA-256-fingerprinted audit log for regulated industries. When per-template audit is enabled, every successful generation captures a SHA-256 fingerprint of the resolved merge values for integrity verification. Writes route through a narrow without sharing audit service so users cannot suppress or forge entries via permission-set holes. (The digest defends against accidental corruption and non-administrator tampering. As with any in-org integrity scheme on the Salesforce platform, a subscriber System Administrator retains the platform-level ability to edit their own data; layer Field History Tracking on the audit object if regulator-grade tamper evidence is a requirement.)
• Retention policies are enforceable. Per-template auto-delete windows are honoured by a nightly sweep; the Generation row survives as audit trail even after the file is gone.
• Least-privilege permission sets out of the box. Three permission sets ship with the package - Admin, User, and Automation - so end users only get the ability to generate, automation accounts only get what they need to run, and admin rights stay with a small group of template authors.
• Reviewed by Salesforce, not by us. Sliick Docs is listed on the AppExchange, which means an independent Salesforce security review has examined the package against the AppExchange Security Requirements before it was made available.

Detailed technical guarantees (sharing semantics, query enforcement, stripInaccessible usage, audit-field write paths) are available on request for security-review processes.

Troubleshooting and reference

Authoring

Batches

Imports

Runtime (end users)

Generated file naming

• Proof files: <Template Name> - v<Version Number> - Proof - <Record Id>.<ext> where <ext> is pdf or docx.
• Runtime files: the per-template File name pattern (with merge-field tokens like {{Account.Name}} - Summary.pdf), or the default {{<BaseObject>.Name}}.pdf if blank. The extension auto-swaps to .docx for Word output. Illegal filename characters are stripped automatically.

What is intentionally NOT in v1.2

• Per-page running headers and footers: the native Salesforce PDF engine doesn’t yet support repeating headers and footers on every page.
• Nested Repeat blocks: one level of looping only.
• Two-hop child paths from inside a Repeat: for example Opportunities.Account.Name inside an Opportunities repeat. Parent lookups outside Repeat blocks go five hops.
• Junction relationships: multi-hop lookups across junction objects.
• External rendering engines: native Salesforce PDF engine and pure-Apex Compression.ZipWriter only - by design, so nothing leaves your org.
• Custom fonts: Arial, Times New Roman, Helvetica, and Courier New only (the fonts the native Salesforce PDF engine supports).
• Word output for Combined / Both batch modes: Word batches require Individual mode.
• Word output for templates with a watermark or barcode block: validator rejects at save. Split into separate templates if both formats are needed.
• Per-template Word theme override on bundle Word output: bundle Word uses the org default theme; single-template Word honours per-template overrides.
• Image watermarks, audience-visibility gating, per-record template scoping, output-format lock, {{RunningUser.*}} / {{Today}} / {{Now}} built-ins, and the Approval History child relationship: all in development for the next release.

Further reading

• Sliick Docs product page
• Contact the Sliick team