Design & Work Flow Concepts

"Pathagoras is different from its competitors. Any similarity is purely coincidental."

Document assembly is, according to one definition, the process of creating documents from precedent clauses. When first introduced, it was thought by many to be the next revolution in legal technology. In actuality, it has been a bit of a bust.

   Why would this be the case? After all, the envisioned cost and time savings that document assembly can bring to an office was unfathomable. But when reality sets in, it was found that most of those who attempt to implement a document assembly system have found the process of preparing the text, the interviews and the coding needed to make it all work to be overly complex and time consuming. Many a well-intentioned soul began the process. Few finished it, and many of those who succeeded did so only with the (paid) help of consultants and experts specially trained in the particular program.

   Enter Pathagoras. Our goal in developing Pathagoras was to create a dynamic, full-featured document assembly program that was simple, intuitive and actually enjoyable to use. We have designed Pathagoras so that every person in every office would want to use it, from 'Pathagorizing' a document (preparing it for use by the end user), to setting up the libraries and books of clauses (telling Pathagoras where the Will clauses, the Real Estate clauses, etc., are stored so they can be instantly displayed for selection) to personalizing the final document (including saving the variable to personal value match-ups so that data need only be entered once).    

   When we began to design Pathagoras, we began with no assumptions. This included an affirmative rejection of the concept that the work flow of existing programs was necessarily correct. We observed work flows in 'real' law offices. We heard the complaints and suggestions from active users of other document assembly programs. And we set to work and wrote the program around what we saw and what we heard. Here is a short list of some of the design requirements:

One comment that we heard often during Pathagoras' initial design was an insistence that the program run within and be a part of the underlying word processing system. Learning a new program just to make an existing one work faster was not acceptable. To achieve that, we started writing the program using VBA, Microsoft® Word's macro language.

There should be no dependency on hidden or 'out of document' fields. Creating fields (those gray blocks of text that changed values depending upon the embedded coding) was often confusing. Even if the document assembly program would create the fields for the end user, they were difficult to modify. It was not always obvious why a document assembled the way that it did because the coding for the document was stored 'somewhere else.'

Creating menus was the most difficult part. Drawing meaningful screens needed to 'interview' the end user was tough. Writing the logic so that appropriate clauses would be selected based on the interview answers was even tougher.

Were the tedious steps needed to create these interviews really necessary? "Why can't all potential clauses simply be displayed in front of us and we can pick and choose the one's we want?" The fancy stuff can come later. For now, "all I want is a quick way to get to my clauses."

Many users wanted to be in total charge of what clauses would be inserted. They did not want a computer program telling them what clauses to use based on an interview. On the other hand, some offices use paralegals and other staff to create the base documents and the attorneys don't want the initial decisions made by a non-attorney. Use to power of computers to remember a specific pattern based on specific criteria.    

The program 'basics' should operate with little set up beyond installation. Significant parts of the program must be usable right 'out of the box.'

The reason what a document works (or doesn't work) the way it does should be 'facial' to the source document. It should be a simple matter of looking at the source text, not ancillary files, to see why an assembled document looks the way that it does, and the source text should be easy to access so that any corrections can be quickly make and quickly tested.

   We concluded that 'document assembly' is initially about getting a reasonable rough draft of a desired document(s) to the screen. What was 'reasonable' varied among users. Some have very low demands. Any text bearing any resemblance to the intended end product would do. Others wanted an almost 'perfect' first draft. (Those wanting the former far outweighed those wanting the latter. This clearly indicated that the complexities involved in getting a 'close-to-perfect' initial draft is what dissuaded even techno-savvy users from using the program more -- or at all.)

  So here is work flow concept #1. The quicker the end-user can get an acceptable version of the final desired text onto an editing screen, the happier that end-user will be. And the happier the end user, the more likely that document assembly would actually be implemented. This is where we set our focus, and this is where Pathagoras shines.

   We made the creation of document variables as simple as possible. Square brackets around placeholder words was to be the primary shape of a variable. And all text was to be 'plain text' (i.e., only regular keyboard characters would be used.

   We practically eliminated the need to navigate up, down, across, further up, further down, your folder/network trees to find documents. But we did so while at the same time not requiring you to change a single thing about the way you currently organize your documents. And this is where Pathagoras begins to separate itself from the pack.

   With Pathagoras, you avoid navigation by setting pointers to your existing folders, and assigning meaningful names to those pointers (typically the current folder name). Once set, you never manually navigate to that folder again. You use 'on-screen' cues and simple clicks of your mouse. The productivity savings with no-more-navigation is immeasurable.

   Personalizing the assembled document to reflect the proper client or customer information was obviously important as well. And that is discussed next. But our users made it clear that just getting something on-screen to manipulate was the most important first step to document assembly nirvana.

   Here are Pathagoras' two primary document assembly tools:

DropDown Lists: This was mentioned in the introduction. Point up to 10 folders (or parent folders if you want to use the 'tree service') to Drop Down Lists and never navigate to them again. So, if you have highly 'Pathagorized' documents or document which you have never prepared for automation, you can quickly bring an exact copy of any item in that folder to your screen by just clicking on the item. Nothing more.

Libraries and Books:  More clicks for a single document (so DDLs are preferred in that setting), but when you want to assembly multiple clauses or multiple documents, this is the way to go. An unlimited number of pointers to you most needed folders, arranged by topic (Estate Planning or Family Law) and specific subject within the library (Wills, Trusts, etc. or Divorce, Separation Agreements, etc.)

   To call a document you wish to prepare for a client or customer, you would either call it from the DropDown List (2 clicks) or select the library then book then specific document(s) from the Clause Selection Screen. A rough draft of the document(s) you selected is instantly brought to the editing screen.

   Once getting text to the screen became 'second nature, adding 'automation elements' to the source documents comes to the fore.

  Work Flow Concept #2: Adding 'automation' elements to source documents must be easy and intuitive. With Pathagoras, automation is accomplished using plain text and remains intact on the face of the source document. Original documents need not be converted, renamed or moved.

   Everything in and about Pathagoras is 'plain text' and 'facial'. Let's take these concepts one at a time:

  Plain text:

Variables are holding places for words you want to add when you are ready to personalize your document. Variables are created simply by surrounding words with square brackets. [Client Name] is a variable.

Optional text blocks are 'keep it or leave it' blocks of text that may or may not remain in the final document. The decision is made at document assembly time. They can be created simply by surrounding words, sentences or entire paragraphs with curly braces.

Options text blocks is commonly known as 'multiple choice text. They are text blocks from which you want to select at least one choice from several that are provided. Options text blocks likewise are words, sentences or entire paragraphs surrounded by curly braces, with the choices be separated by "/OR".
(We describe the simplest iteration of Options and Optional text blocks in the above sections. More robust alternatives are available for the advanced user, allowing complex selections and promptings for the end user.)

Just a note here. Some competitive programs also claim that their editing for automation is done in 'plain text.' There is a half-truth to their assertions. Initial automation markups can be done in plain text. The problem is that when you have finished editing and press the buttons to make it part of their systems, they convert your work into a new document, replacing your typing with their hidden fields and links. They sometimes move the document to a new location and almost always rename it, assigning a foreign extension and creating a tag-along document which contains additional instructions for processing the file.

   None of that happens in Pathagoras. When you have finished editing your document, just save it. When you need to edit it again, you recall it from its same location. It starts as a Word document. All intermediate steps are done in Word and the final product is a Word document. We call this "All Word, all the time."

Facial text: The culmination of the above 'rant' is Pathagoras' concept of faciality. What you type is what you keep. No conversions. No fields. Document automation triggers are typed on the document's face and remain there until the document is automated. If your document does not process correctly, you can 'read' on the face of the document what went wrong. You do not have to consult the ancillary files (where ever they may be), edit the fields, convert and then reconvert. So 'Word-like' (here we are referring to Microsoft Word) is the process that when something goes wrong, you can simply press the Undo button on the assembled document. This lets you step backwards through the process to see what Pathagoras did with the variables and options text you provided. This makes it very easy to see (albeit in reverse) what Pathagoras is doing with your markups so you can correct the original if the need be.

   Once you have edited and saved your document, refer to Work Flow Concept #1 to access you document.

Here is BIG WARNING #1:            

Never use an original document to serve as your base for a document assembly session.

   So long as you abide by the above rule, you will not accidentally overwrite your source documents. (We are sure that it has never happened to you, but some people forget to save the edited documents under a new name. The original document is therefore lost. When you heed BIG WARNING #1, and follow the document assembly steps stated above, you minimize the chances of that occurring.

   When a document is brought onto the screen using Pathagoras tools you will always be working on an exact copy of the original How do you know it is a copy? Look for the 'name' of the document in the upper left-hand corner of the screen. It will be named "Document1", "Document5", etc.

   If you find yourself working on the original for other than source editing purposes, you should rethink your process, and implement the tools provided by the program. If you do nothing else in your early days with the program you should at least "Create your First Library" and "Shelve your First Book" and call up copies of documents from your various books. If you find yourself working primarily on complete documents or templates, consider our exceptionally popular DropDown Lists.

Adding New source text (Pathagoras Work Flow Concept #3).

   Once you begin using Pathagoras, you will begin to muse, 'Gee, I sure wish I could easily and quickly add additional documents to the folders I assigned to my books or to my DropDown Lists." (Well, maybe you won't state it quite that way, but the thought will nevertheless cross your mind.)

   The process is (or course) simple, and no navigation is ever required.

   Depending upon the source of the text you want to add, you have several choices.

   Copying existing documents from 'other' folders:

To DropDown List folder: If you are moving multiple files, copy files from the source folder by highlighting them, right clicking and "Copy". Then, click Display Folder from the appropriate DropDown List. When the folder displays, right click and select "Paste." (Ctrl-C and Ctrl-V work as well.) If the text you want to move is 'on-screen," simply highlight it (if you only want a portion). Drop down the appropriate DropDown List and select the "Save to Folder" element.

To Libraries and Books folder: If you are moving multiple files, highlight their names in the folder. (By folder, we mean simply the folder into which you navigated using regular Word/Windows navigation tools. You are simply locating files you want to add to a folder which you have identified to Pathagoras as a book.) Right click on your selection and click "Copy". Close that menu. The selected documents are now in your 'clipboard.' Next, using the Document Assembly button, select the library and then the book into which you wish to add the new documents. Click "Display Folder" option from the expanded screen and click Next. A standard Word 'file open' dialog displays. After the folder displays, right click in any 'blank' area of the screen and click "Paste." (Ctrl-C and Ctrl-V work as well to copy and paste the files.)

   Moving 'on-screen' text into source folder:

To DropDown List folder: Highlight the portion of text you want to add to the folder associated with your DropDown List. Drop down the appropriate List and select the "Save to Folder" element. Pathagoras will copy the highlighted text into a new document and save it with a name that you provide into the target folder.

To Libraries and Books folder: Highlight the portion of text you want to add to the folder associated with you book. Select the appropriate Library and then Book and select the "Save to Folder" from the expanded screen. Click Next. Pathagoras will copy the highlighted text into a new document and save it with a name that you provide into the target folder.

(Of course, you can always move files into a target folder the 'old fashioned' way, and if you have several documents to move around, you can use standard file manipulation tools. But if you have 'free text' or a single document, the steps listed above cannot be beat for speed.)

   Notice that all the above is irrespective of the nature of the documents being moved.

  Workflow Concept #3: There is no such thing as a 'Pathagoras document.' Pathagoras owns no document. There are only documents, and they carry the definition of documents according to Word and Windows, not Pathagoras. (Don't get us wrong. You can 'Pathagorize' a document by adding brackets around variables, and by adding Options and Optional text blocks, but the result is still Word document with the same name (unless you decide to change it) and extension (.doc or docx) as the one you began with.

  Workflow Concept #4: Pathagoras goal is to make your document creation tasks easier, not different.

   There is a lot more to the program, of course, than discussed above, but this should get you started with a solid understanding of Pathagoras' approach to document assembly.

  Workflow Concept #5: It should be easy to add new text or to access for edit existing text to any document assembly system.

Marketing Concepts:            

While we were at it, we decided to include our philosophy regarding marketing.

   Marketing Concept #1: Demonstrate the program on the potential customers computer. No tricks up our sleeves. We show you how easy it is, and how to do it, live using your documents.

   Marketing Concept #2: Show prices on the website.

   Marketing Concept #3: Don't ask for life history to allow the viewing of our websites and videos.

   Marketing Concept #4: Don't nag. Maybe every once in a while send a newsletter or mailing to ask how things are going, but don't nag.

   Marketing Concept #5: Be as available before the sale as after it.

   Marketing Concept #6: Be as available after the sale as before it.

   Marketing Concept #7: Leave the user better off for having tried the program (or at least no worse off.) Example: Many customers 'coded' their variables like this: ********* and/or ________________. During a demo, we may replace those 'variables' with much more meaningful variables like "[Date of Letter]", "[Client Name]" and "[Child@1]". The customer may decide not to buy the program, but doesn't have to undo the changes made. Indeed, he or she has a better document in exchange for the trial. So your efforts at the trial are not wasted.

   Marketing Concept #8:  Offer features that are not dependent upon document coding. Allow the user to use the program when purchased, not just after the program has been fully configured. We can brag about two of these features: "DropDown Lists" and the "Names and Subjects Editor". These are spin off programs, potentially stand alone. By the same token, they are also at the heart and soul of Pathagoras.


   If it is challenging to locate the source text to edit it, or to add more source text, a typical user doesn't even try in many case. So we had to make it easy and consistent with the way the typical user already functions.

   When you want to create or edit source text, that too can be done without navigation. ('Source text' means the documents and other files that you want to store in the folders targeted by your books and DropDown List. It is from 'source text' that a copy is called when you take the above document assembly steps.)

   Pathagoras' allows you quick access to your source text:

From DropDown Lists: Drop down the list. Locate and click on the element called "Display Folder". A standard Word 'file open' dialog displays. Simply select the original file you wish to edit.

From Libraries and Books:  Click the document assembly button. Select the library and then book. Click the "Display Folder" option from the expanded screen and click Next. A standard Word 'file open' dialog displays. Simply select the original file you wish to edit.

Using existing Word tools: Don't forget that you are in Word. Word maintains a Recently Used Files list. Use that list when you need to edit a file you just worked on. If you are editing, testing, reediting, retesting a document, this likely is the fastest way to access your work. And it is a perfectly acceptable (indeed, preferred) technique.

  Pathagoras saves you time even if you don't 'Pathagorize' a single document. Even if you have inserted no brackets, no optional text, etc., into a single document, the fact that you can quickly call up a document onto the editing screen is a meaningful time saver. Some customers have bought the program for the DropDown List feature alone.

   When we demo, we demo when possible on your computer.