Understanding Knackly's internal structure is vital to being able to use it efficiently and effectively. Knackly's structure is based on models. There are three types of model, which each have a different purpose.


A catalog model is the first model that will need to be created if you are starting from a completely blank Knackly instance. A catalog is where all the specific information for your document system is held. You can have several catalogs on your Knackly instance; for example, you might have an 'EstatePlans' catalog and a 'LoanDocuments' catalog to serve different purposes. Catalogs contain Variables, Templates, Formulas, and Apps, which are all explained in the relevant sections below.


A table model is just what it sounds like, a table of information. These are used when you have static information that may need to get pulled into your documents over and over again – for example, you could have a table model with all of the different states listed. Tables allow you to tie different information to one entry, which can be useful when you want several items to be related to a single answer.

Example: For the 'New York' state entry in your table, the first and main entry would be New York. Then you might have a column for the postal abbreviation (NY) and a column to reference the state's department of labor (New York State Department of Labor). This way, when you have a state tied to a particular piece of information – like an individual or an entity – you can use that one answer to pull information from the relevant column into your documents, instead of having to enter it separately.

Here is a video that shows how tables work.


An object model is the last and possibly the most important model in Knackly. Objects are versatile, discrete building blocks that group pieces of information together and can be reused over and over again in your Knackly instance. Objects allow you to reuse specific kinds and groupings of variables without needing to recreate them every time.

Example: For instance, most document systems will use some type of 'person' or 'individual' object – on this object, you would create variables for a person's name, address, and contact information, and then use the object for specific instances of people in your documents. Using objects saves you time – you can just reuse the generic group of information you have already created and tie it to a specific person in your documents, rather than having to create a different 'name' variable for every person.

Objects can also be used across different catalogs. In your 'EstatePlan' catalog, you might have Client, Spouse, and Children variables all based on the 'person' object, but in your 'LoanDocuments' catalog, the variables based on the 'person' object would more likely be things like Borrower and Guarantor.

Basic Definitions:


A variable is the basic unit of data in Knackly. Think of variables as the smallest building blocks on which your automation system is built. There are several different kinds of variables, which are explained further in the Variable Types section below.


An instruction is a command used to tell Knackly to perform a specific task within your template. Examples of instruction tasks include bringing in content if certain conditions are selected and displaying a list of variables.

Example: if statements are a common use of instructions. They open with an if instruction that includes a True/False variable and close with an endif instruction. Anything in between the if and endif instructions comes into document only when the referenced True/False variable is true. For a True/False variable Married to bring in a spouse's name only for a married client, you would use: {[if Married]}{[SpouseName]}{[endif]}

Initial Rules:

  • Instructions or variables in a docx template or Knackly field must be in paired curvy and plain brackets: i.e., {[VariableName]}

  • Instructions or variables that are part of expressions (specific fields in Knackly that are clearly marked as requesting an "expression") do not need to be in paired brackets: i.e., VariableName

  • Instructions must be in lowercase and be one word: i.e., {[elseif]}, not {[else if]}.

  • Filters, punctuation, and formatting use the pipe character |. {[PersonName|upper]} with input content "John Doe" would bring JOHN DOE into the template. A list of filters, punctuation, and formatting examples is located here.

  • Selections require a double equals sign – the syntax for a single selection variable is {[if ClientState == "Utah"]}, not {[if ClientState = "Utah"]}. This will make more sense once you get further into using Knackly.

    However, to do the opposite – refer to when a selection variable is NOT a certain value – you use a single equals sign ({[if ClientState != "Utah"]}).

Variable Types:

Text, Number, Date, True/False, Selection, Object

Each type of variable has different properties, filters, formatting, and uses that can be applied to improve your template.


Text variables are the most basic type of variable. They are plain text entries, and are useful for the names of people and places, phone numbers, addresses, and any other information your user would type in manually. Text variables have the following features:

Intake pattern: You can require the text input to be in certain formats – i.e., (999) 999-9999 will allow the users to only input numbers in that text variable, and will format the numbers like a telephone number. This can be useful for zip codes (99999), social security numbers (999-99-9999), and file numbers (AAA-9999 for a filing system where the first three digits are letters and the last four are numbers). The tokens that you can use for these intake examples are:

  • 9: any digit 0-9
  • A: any upper- or lower-case letter
  • X: any upper- or lower-case letter or digit (combination of 9 and A)
  • L: any lower-case letter
  • U: any upper-case letter

Validation: You can select whether to allow line breaks in the text input, which would carry any line breaks (new paragraphs) in the text entry over into the template. You can also select whether to allow markup in the text entry – i.e., bolding, italicizing, and other simple text formatting.

Answer suggestions: You can provide answer suggests for text variables; these appear as a dropdown for the user, so that the user can select one of the suggested answers or type in their own. This is useful for situations where you might have a number of possible set answers or users may need to enter more unique answers. For example, in a field requesting a person's relationship to another person, you might have a list of typical relationships (brother, sister, step-sister, daughter, son) as well as permitting users to type in less common relationships (step-daughter-in-law, grand-uncle, second cousin twice removed).

Input height: The default input height for text variables is one line. You can change this to multiple lines to allow users to input larger blocks of text.

Here is a video that describes the options for text variables.


Number variables are important for things like fees, asset values, loan amounts, and any other numeric information you would want to be able to manipulate mathematically. Number variables have the following options:

Intake style: You can choose whether to present the user with a box to type the number into (the default), or if you'd rather, the input can be a spinbox (a type of entry where the user can either key in numbers or use up and down arrows) or a slider.

Decimal places: You can determine how many decimal places you want the input number to have – useful for monetary amounts and places where precise amounts are necessary.

Minimum: You can set the lowest number the user may input.

Maximum: You can also set the highest number the user may input.

Here is a video that describes the options for number variables.


Date variables are useful for birthdates, loan origination dates, dates assets were acquired, and other instances where you might need to know the days/months/years between different dates. In estate planning, for example, it's often useful to automatically determine whether any of the client's children are still minors; this can be calculated using each child's birthdate. Date variables have the following options:

Intake style: You can choose whether users enter dates through a date picker (a popup calendar where they can click to find the date they need) or type in the date via text box.

Here is a video that describes the options for date variables.


True/False variables are useful in controlling content and entering in information based on different conditions, such as in the Married example above in the Basic Definitions section under Instructions. True/False variables have the following options:

Intake style: You can choose whether the user selects a check box (the default), toggles a yes/no switch, or selects between yes/no radio buttons.

Default value: You can choose whether True/False values are initialized as true or initialized as false. Knackly's default is that True/False values are initialized as false (i.e., all True/False values are false until they're selected as true by the user), but you can use this option to change that.

Here is a video that describes the options for true/false variables.


Selection variables are where the user is presented with a choice of options and may select one or several of the options given. For instance, when presenting the user with a list of states to choose from for an address, the list of states would be a selection variable. Selection values have the following options:

Select from: You can choose whether the options the user can select from are ones you enter on the specific selection variable, or whether the options come in from a table or user input. For options that you are going to use over and over again, like states, it would make sense to make a table of states and then have all your state selection variables draw from that table; however, if you're only going to use the options you want in this one selection variable, then it would make more sense to just enter the options on that selection variable.

Input Style: You can choose whether the user selects from a dropdown box, checkboxes, a list box, or radio buttons.

Option template: You can choose what is actually displayed to the user here. For instance, if a user is selecting from a list of documents, your list of options may be "PouroverWill, JointTrust, IIOT" but you want the user to actually see "Create a Pourover Will, Create a Joint Revocable Trust, Create an Irrevocable Income-Only Trust". You can put the second list into a column under the options and call the column "Description". Then in the option template, if you put {[Description]}, the users will see the items in the Description column.

Here is a video that describes the options for Selection variables.


Objects are used to group related pieces of data (i.e., variables) that can be manipulated to suit your needs. Objects are where a great deal of Knackly's flexibility and more dynamic capabilities come into play.

Objects don't have options like most other variables, as the specifics of the object are contained in the object itself.

Other variable properties:


Relevancy is whether or not a variable is asked in the data-entry interview. Relevancy is automatic by default – that is, if variables are used in the template(s) in any way, they are asked in the interview. However, you can also set the relevance of a particular variable if you need to.


The label is the prompt the user actually sees when they are going through the interview. This defaults to the name of the variable, but you will almost certainly want to change it to be easier to read and understand. A variable named "ClientExecutors" is clear enough when you're reading it in the template, but having the label be "Enter the executors for the Client" is probably a better experience for your users.

Help text:

Help text can be added to a variable if users will need additional help or information as to what they should enter for the variable. If help text is entered, a question mark will appear in the interview next to the variable, and when users click on it, they will see a pop-up with the help text for that variable.

Variables can be either a single entry of one type or can be a list of entries of one type.


Lists differ from single entry variables in that they allow you to manipulate items in a list in ways you wouldn't be able to if the list was entered as a single text variable.

For instance, you could ask your user to enter all of their children into a single text variable (i.e. "Joe Johnson, Emma Johnson, and Mandy Johnson"). However, that single text variable wouldn't allow you to bring in the various children in different groupings for different purposes – it would only ever bring in "Joe Johnson, Emma Johnson, and Mandy Johnson". If you wanted to list only the minor children, your client would need to enter another text variable with just their minor children ("Mandy Johnson").

If you use a list variable instead, each item on the list would be an individual child, and you could include as much information related to that child as you needed (name, age, address, etc). Then you would be able to re-use that list over and over, formatting and filtering it as needed. This would allow you to list minor children, adult children, disinherited children, order the children by age, and many other configurations all from a list that only needed to be entered once.

List formatting, filters, and punctuation examples are available and


Knackly uses two types of templates: docx templates and text templates.

Docx Templates:

Docx templates are created in regular Word documents. You don't need to do anything special to your Word document to turn it into a template, other than adding the actual instructions and variables. These can either be typed into Word with the paired brackets, or can be copied in from Knackly and then adjusted as necessary.

Text Templates:

Text templates are created in Knackly itself instead of in a Word document, but text templates can be referenced inside of your Word templates, as well as in many other useful places. Text templates are a way to put together text that you need to use in the same format often. For instance, if you have a First, Middle, and Last name for several different people, you can create a FullName template to combine each person's name – including bringing in the appropriate spacing depending on whether that person has a middle name.


Apps are what Knackly uses to gather information and produce your documents. An app’s logic typically is derived from at least one docx template, but can (and in most document systems, likely should) be derived from several templates. Apps use the order of variables on your catalog, combined with the relevancy of those variables, to ask the variables that are needed for the documents you want to produce. Then the app fills the information into the docx template and produces a finished document.


Formulas allow you to create a flexible, dynamic document creation system in Knackly. You can use formulas to group several lists together in one list, to test several true/false statements and condense them into one field, and to bring complex strings of text into your document – among many other uses.

Formulas are composed of expressions. Expressions are the basic syntax used for Knackly to combine or transform pieces of information according to the needs of your documents. Previously, we have looked at the syntax for statements and variables inside nested brackets, but expressions are the base logic behind what goes into the brackets.

Expressions don't use the nested brackets {[Variable]} for variables and instructions, and instead of regular if statements, expressions use a conditional operator.

In a text or docx template, for an if statement you might write the following:

{[if Married]}{[Client.Name]} and {[Spouse.Name]}{[else]}{[Client.Name]}{[endif]}

However, in an expression, you would use the conditional operator to achieve this result:

Married ? Client.Name + " and " + Spouse.Name : Client.Name

Essentially, the conditional operator tests the first condition you give it (the thing before the question mark), and if that condition is true it returns the first result (the thing after the question mark, or before the colon), and if that condition is false then it returns the second result (the thing after the colon). The conditional operator can be nested. For example, if you wanted to use one salutation for married clients with the same last name, another salutation for married clients with different last names, and a third salutation for a single client, in an if statement inside a template you would do something like this:

{[if Married]}{[if Spouse.Last == Client.Last]}Mr. and Mrs. {[Client.Last]}{[else]}Mr. {[Client.Last]} and Ms. {[Spouse.Last]}{[endif]}{[else]}Mr. {[Client.Last]}{[endif]}

Whereas in an expression using the conditional operator, you would set up the formula like this:

Married ? Spouse.Last == Client.Last ? "Mr. and Mrs. " + Client.Last : "Mr. " + Client.Last + " and Ms. " + Spouse.Last : "Mr. " + Client.Last

Once your formula is created, you can use it just as you would use any other variable of its type. A True/False formula can be used in your template exactly as you would use a True/False variable; list formulas would be used like any list variable, etc.

One places formulas are extremely useful is creating lists for selection variables. For instance, in most estate planning systems, you might have several types of 'individual' objects (Spouse 1, Spouse 2, a list of children, and a list of other individuals named in the documents). By creating a list formula that combines all of those individuals into one list, you can present your user with a selection variable of individuals they've already entered into the system, and they can use that selection variable to select people as Executors, Trustees, Agents, and Beneficiaries. This way, users don't need to retype information for "Joe Smith" if Joe Smith is fulfilling several roles in the estate plan.