Fill Financial Documents for Account Openings

Feathery maintains a library of 40,000+ financial forms across major financial institutions that allow for automated filling and e-signature. Easily fill PDFs for account openings and other actions.

Feathery maintains a library of 40,000+ financial PDF forms across major financial institutions that allow for automated filling and e-signature. Collect the information in your Feathery workflow and then automatically fill that information into a set of financial PDF forms.

Getting Started

Navigate to the Feathery form that you want to set up. Click on the Integrations tab and navigate to the Quik integration. Follow the configuration guide below, and once configured, click Connect to activate your integration and the form filling workflow.

Authenticate

Open the Quik integration and input your Quik account credentials. If you do not specify account credentials, a test account will be used by default.

Choose Forms to Fill

Specify if you want to choose a static list of Quik PDF forms to fill out or dynamically configure the forms, ordering, and prefill logic. The second option is useful for more complex use cases that have complex mapping rules and need to pull from third-party systems like CRMs.

Static Form IDs

Specify a list of Quik PDF form IDs that you'd like to connect to your Feathery form workflow. You can also make specific forms conditional by appending :<FieldId> to the Quik PDF form ID you specify. Here, FieldId refers to a field within your Feathery form. These Quik PDF forms will only be included and filled out if your submission has a value for the field corresponding to <FieldId>.

Dynamic Form Order and Prefill

In this approach, the included forms, order, grouping, and data prefill configuration are all specified via a data structure stored into a hidden field. This is useful for advanced mappings that might also need to integrate with third-party data sources like a CRM. This hidden field will need to be constructed via advanced logic.

The base format of the hidden field is [{"forms": [{"id": <Form ID>}]}], where <Form ID> is the ID of a Quik form to include. Each object in the array corresponds to a bundle of forms that will be filled with separate data. The forms will be filled and displayed in the same order that they're in within the array.

If your Salesforce account is connected and you have a Salesforce prefill mapping specified, you may include a salesforce_prefill property in the format [{"object": <Salesforce Object Type>, "id": <Salesforce Object ID>, "quik_entities": [<Quik Entity>]}] to specify a list of Salesforce objects to pull from and their corresponding Quik entities to map to.

If you have a CSV mapping uploaded between Feathery and Quik fields, you may include a csv_prefill property in the format ["1ben", "2ben"] to specify a list of Quik entities to pull in the corresponding Feathery field data for.

You may also include a feathery_prefill property in the format [{"repeat_index": 0, "quik_entities": ["1ben", "2ben"]}] . This allows you to connect Quik mappings specified directly on the properties of a form field.

Other Form Fill Settings

You can also configure other miscellaneous settings related to filling out Quik forms such as enabling draft mode, showing Quik field IDs on the generated PDFs, and statically predefining Quik field values to fill out on the generated forms.

Connect Data to Quik Forms

Aside from specifying which Quik PDF forms to fill out via your Feathery workflow, you'll also need to configure how the data within the forms are filled out. At a high level, there are two main ways you can do this - send data collected from the Feathery workflow directly and/or pull it in from third party systems like a CRM.

Map Feathery Form Fields to Quik Form Fields via CSV

You can map Feathery fields to Quik fields by uploading a spreadsheet with two columns - Feathery Field and Quik Field. Each column contains the corresponding IDs for that field type.

Map Feathery Form Fields to Quik Form Fields via UI

You can also map a given form field to a Quik field by mapping it from the Feathery designer. Select the field, go to the Properties tab, and under the Quik Field section you'll be able to specify the data set and field ID.

Map Data from Third-Party Systems

You can pull in data from third-party systems like a Salesforce CRM. For Salesforce, Feathery streamlines the process of integrating Salesforce with Quik by allowing users to upload a CSV file that defines how fields map between the two systems. This eliminates the need for manual data entry and ensures accuracy in your Salesforce API connectors when creating or updating records.

Map Static Field Data

Define static data to be filled into specific Quik fields. Each line must include the Quik field ID, the value to fill into the field, and an optional comma-separated list of form IDs that this mapping applies to. Each of these 2-3 values must be separated with a colon. The structure may look something like: 1rep.BDCompany:Feathery Advisors:12,100,23 .

You may also specify the same Quik field multiple times on different lines with different form IDs conditionally applied. For a particular form, the entry more specifically targetted towards that form will apply.

CSV Format

• Your CSV file must contain three columns:

  • Salesforce Object – The specific Salesforce object (e.g., Account, Contact, Lead).

  • Salesforce Field – The field within the Salesforce object

  • Quik Field – The corresponding field in Quik that maps to the Salesforce field.

• Each row in the file represents a single mapping between a Salesforce field and a Quik field for a given Salesforce object.

CSV containing Salesforce <> Quik field mapping information

Automatic Field Prepopulation

Once this mapping is specified, the following will occur:

• When leveraging dynamic form prefill, you can specify the salesforce_prefill property which will automatically leverage this mapping to pull data from Salesforce.

• Feathery will automatically detect and apply the mappings from your CSV when building Salesforce API Connectors. Feathery will pre-populate the mapped fields with the corresponding Feathery field ID:

Value Transformation

You can define an optional Value Map column in both the Feathery and Salesforce Quik field mapping CSV uploads. When present, it defines a set of transformation rules that are applied to field values before they are mapped to Quik at prefill.

CSV Format

Add a Value Map column to your existing field mapping CSV:

Feathery Field	Quik Field	Value Map
disclosure_signed	App.DisclosureSign	true->1|false->0
applicant_name	App.ApplicantName

Each entry in the Value Map column is a |-separated list of from->to transformation pairs. For example, true->1|false->0 will convert the value true to 1 and false to 0. If there is no value map defined for a field, or the field's value does not match a mapping rule, the field value will be passed to Quik unchanged.

Catch-all Transformations

You can define a *->to mapping that applies to any value not matched by another transformation rule in the Value Map. This is useful when you want to standardize unexpected inputs.

How it works:

• Explicit from->to rules take precedence. The catch-all only applies when no other rule in the Value Map matches the incoming value.

• Empty values are never transformed by the catch-all. A blank field will be passed to Quik as empty, even if *->to is defined.

Generate Forms

Typically, you would add a button to the final step of your form that will generate the auto populated Quik forms based on the mappings configured previously. Select the button and navigate to the Button Properties tab. Choose the action Fill Quik Documents.

Under the Sign Method dropdown, you can pick either Feathery or Quik. This controls the behavior of the Quik PDF forms after they are filled.

• Feathery: Your Quik PDF forms will be e-signable through Feathery or directly downloaded.

• Quik: Your Quik PDF forms will be displayed in a custom form viewer in the workflow for easy review. This option also supports a DocuSign integration to seamlessly send the forms for e-signature afterwards.

Attaching documents and envelopes

You can include Feathery document templates or existing document envelopes in the generated form bundle. Each attachment is placed either before or after the generated Quik forms. This controls attachment placement only. It does not change the order of generated Quik forms.

On your Fill Quik Documents button action, click Documents to select the attachments to include. Each attachment can be placed before or after the generated Quik forms, and attachments will keep the order they're configured in within each placement.

You can also select attachments dynamically at runtime via a hidden field. This is useful when the attached documents are generated by earlier steps in your workflow or selected by the end user. In the Documents configuration, choose Dynamic attachment and select the hidden field that will store the attachment IDs. Like other attachments, each dynamic attachment is placed before or after the generated Quik forms.

The hidden field must store a list of IDs in the format ["<document-template-id-1>", "<envelope-id>"]. This hidden field will need to be constructed via advanced logic.

• Each id can refer to either a document template or an existing document envelope.

• The documents will be placed at the position of their configured attachment, in the same order that they're in within the array.

• You may configure multiple dynamic attachments that read from different hidden fields.

• Placement is controlled by the attachment configuration. Only lists of ID strings are supported, and other values will be ignored.

Attaching documents and envelopes via advanced logic

You can also generate Quik forms using the feathery.fillQuikForms function in advanced logic. When using advanced logic, you can include Feathery document templates or existing envelopes in the generated form bundle.

To do so, populate the attachments parameter in the fillQuikForms method.

await feathery.fillQuikForms({
  fillType: 'html',
  docusignConnectionId: '<docusign-connection-id>',
  attachments: [
    { id: '<document-template-id-1>', position: 'before' },
    { id: '<document-template-id-2>', position: 'before' },
    { id: '<envelope-id>', position: 'after' },
  ],
});

Each id can refer to either a document template or an existing document envelope.

Attachments are ordered by:

• position: 'before' - places the attachment before the generated Quik forms

• position: 'after' - places the attachment after the generated Quik forms

• Ordering is maintained for each document with the same position.

If position field is omitted, it is defaulted to position: after .

This controls attachment placement only. It does not change the order of generated Quik forms.

eSignature Setup

Feathery eSign

Feathery's native eSignature solution is great for all use cases that don't involve a specific requirement for a different eSignature platform. This can be used seamlessly with the Feathery sign method above.

Docusign

Feathery offers a native Docusign integration through Quik for custodians that require eSignature of completed documents through Docusign.

1. Enable the DocuSign connection in your Quik Forms App. Refer to the relevant Quik! documentation for more details.

2. On your Fill Quik Documents button action, click Enable DocuSign and include the name of your Docusign connection(s). If a test connection is specified, it will be used on the test Feathery form and the normal connection will be used on the live Feathery form.

3. The Quik integration configuration under the Integrations tab offers more extensive customization options for the e-signature process, including custom invite emails, routing patterns, and more.

Additional Recipients for Docusign Envelopes

Aside from the signatories for the auto-generated Docusign envelopes, who will be automatically included, you may also manually include additional non-signing recipients for the envelopes.

You can also conditionally exclude different forms in the envelope from the additional signatories. This is a common use case when you're routing completed forms to a receiving custodian and have your own firm's forms in the envelope as well. You only need to show the custodial forms to the custodian with no custom firm forms included. You would include recipients in the format:

[e-mail]:<my-form-id-1>,<my-form-id-2>
[e-mail]:<my-form-id-3>,<my-form-id-4>

Route Completed Documents

Once your forms have been e-signed through Feathery or Docusign, you can automatically route them to an end system. Some examples are included below.

Salesforce

When Salesforce sync is enabled, you can have Docusigned envelopes automatically be sent back to your Salesforce account, attached to a custom record type, and custom Docusign information populated into the record as well.

eFax

Signed documents can be configured to be e-faxed to custom fax numbers depending on the form.

Feathery Form Templates

Feathery allows you to build Feathery forms from a list of supported Quik forms.

Click the Create Form button and choose the Financial Services Form Library option.

In the Template dropdown, select a Quik form to use for building your Feathery form:

Click Create, and a Feathery form will be generated that includes all form fields automatically linked to the corresponding Quik! form fields.