Revisiting How the Nonprofit Planner Fits Into My Theme

As I get deep in an actual web application, like the Nonprofit Planner and Grant Generator, it is easy to lose track of what my overall goal is with this blog and my book "The Shape of Knowledge".

My main message is, and has been, that there are basic knowledge patterns that capture important types of reasoning. The pattern I am elaborating on here is a Composer, which captures content once and then configures and reconfigures it into various documents to meet a particular need.

The value of identifying these patterns is that a talented developer, like my partner Steve, can write a powerful program that consumes predefined knowledge artifacts created by domain experts and then generates a web app automatically based on that knowledge. I call this type of program an application generator, or an 'apperator', for short.

At the same time, the identification of knowledge patterns empowers us, the knowledge authors who create the knowledge artifacts, because we can use these 'apperator' programs to build our own custom solutions without writing code.

In this particular case, I built a template using KnowtShare (our online collaboration tool), and made it available to charities for developing and documenting their business plans. The shape of that template, and therefore all plans created using it, is a hierarchical tree model. I call this shape a 'triangle' because it grows from a single root to the many 'leaves' of the tree. This tree/triangle is the knowledge artifact that stores the raw material for the Grant Composer. Each charity will create and maintain its own business plan.

There is a second artifact required, and it is built and maintained by me, as a community resource. That is a table -- a 'square' -- containing the information requirements for particular foundations.

The 'apperator' Steve has written is a Composer that knows how to consume these two types of artifacts: a hierarchical KnowtShare file filled with written information items and a .csv file that contains a matrix of communication targets (foundations) and their preferred order for those information items. Context questions are used to identify which branches of the tree and which rows of the table to use when creating a solution at run-time.

I, as the knowledge author, decided to use business plan information to populate a grant application for foundations, so the actual app that is created is a Grant Application Generator. But the same pattern could be used to collect an individual's CV and generate a customized resume for a particular company -- that would be a Resume Generator. Or a student's transcript and essay questions to generate a customized college application -- that would be a College Application Generator. This makes sense: these examples are very similar to the Grant Generator.

What about something further afield? There's a whole industry evolving around using legal boilerplate and context questions to generate legal documents. The Composer pattern could be used to achieve the same results, and with far less programming.

My last post was dedicated to describing how the very same business planning information used in grant applications can be used to generate other reports and marketing materials. All of these are examples of the Composer Pattern and can be created by the same aperator with only minor tweaks.

The Composer is just one pattern. I have written about the Recommender pattern and the Scoring pattern as well, and I will be describing others going forward.

The challenge, and the opportunity, come from thinking about problem solving at a higher level of abstraction than we normally do.

Most applications are built to solve a particular problem. The IT team interviews their customers to determine the functional specifications for an application they want built. Then the IT people go off and build it, checking back in periodically with the customers to make sure they're still on track.

Typically there is a deadline looming, and everyone is focused on the problem at hand. No one is interested in investing time (and money) in designing a meta solution that will make the next problem easier to solve. In fact, if programming is paid for on an hourly basis, there is a disincentive to look for the patterns that will make application development more efficient. But as knowledge authors, and as problem solvers in general, there are many benefits to identifying and harnessing new patterns.

Knowledge patterns only become visible when you are exposed to many different but similar problems, and when you look for them. It also helps to have a vocabulary and a mental framework that make it easier to discuss the patterns you sense are emerging. My goal is to contribute to the creation of those foundational tools, and to create real world examples that will stimulate discussion.

One More Input to the Nonprofit Planning System

I said in the prior post that two knowledge artifacts are required to run the Grant Generator: the Business Plan Tree, which provides the content, and the Foundation Sequencing Table, which provides the assembly instructions. There is one other input, a community asset that I build and maintain along with the Sequencing Table, which I call the Nonprofit Element Attribute table.

In the process of building the Nonprofit Planner and Grant Generator, there were certain design and formatting decisions that were left to me as the knowledge author. One was the rules for when to use the green 'completeness' highlighting in the business plan, and the other was how to format the output in the grant application.

First, I'll explain the completeness rules. Remember, in KnowtPlan, when an item is completed it is outlined in green in the note view and highlighted in green in the outline view.

The rule for when to apply the highlighting to the 'leaves' of the tree is simple: when both the short and long answer are filled in, add the green outline. So the completeness rule for 'Organization's Mission Statement' is 'self'; it is highlighted as soon as its 'self' is complete.

The rules for how to roll the highlighting up to higher levels in the tree are somewhat more complicated. That is because some of the higher level notes require their own answers and some are just headers added for organization purposes.

An example of a note that is just a header is 'SWOT Analysis'. It has no content; if you clicked on it, you would not get a popup window asking for a long and short answer. So its completeness rule is 'children'; it is highlighted as soon as all of its children are highlighted. In the screenshot above, SWOT is not highlighted because two of its attached notes have not been filled in yet.

On the other hand, 'Organization's Purpose' is a note that acts as a header but also requires its own content. The charity is expected to fill in the organization's purpose, which should be short and compelling - different from a mission statement, which can be rather wordy. So the completeness rule for 'Organization's Purpose' is 'both': it is considered complete when all of its children are completed AND its own content is filled in.

So one piece of information I have to provide is the completeness rule for every item in the plan. I do this by adding an attribute called 'completeness' and setting its value to 'self', 'children' or 'both'. A second attribute I need to provide for each item is how it should be formatted in the grant application that is generated. This is similar to assigning a paragraph style in Microsoft Word.

Even though we ask for a 'long' and 'short' answer for each question, it is clear from working with the actual content that some answers tend to be much longer than others. For example, contact info tends to be very short. Descriptions of the Board members, on the other hand, tend to be much longer.

So we created two different paragraph styles: 'inline' puts the question header on the same line as the response pulled from the business plan; 'paragraph' puts the header on a separate line. There are also headers, the ones that have no content of their own, that never show up in the generated grant application. Their style is set to 'none'. This became a second attribute.

I'm sure there will be other attributes that will surface as we continue to develop the Nonprofit system. To make it easy to expand and maintain this sort of information, we capture it in a table that is easy for me to change, and doesn't require changes in computer code. The current version of the Nonprofit Element Attribute Table looks like this:

The Grant Application Generator

While the process of creating a 'composer' that generates grant applications highlighted the need for charities to do better planning, I have never lost sight of my original intention. Yes, the Nonprofit Planner has value on its own, but the magic of the tool is that it collects important content in a highly reusable form. The first composer we have built to utilize this content is the Grant Generator, and there will be other composers down the road that can use the planning content as well.

In my book, and in prior posts about the Recommender, I talked about knowledge patterns. I have defined a knowledge pattern as a consistent set of knowledge artifacts that can be used over and over again to solve a certain type of problem. The knowledge pattern for a Recommender looks like this:

I've written a series of posts about applying this pattern to build a Whiskey Recommender.

The pattern for a Composer is remarkably similar to that of a Recommender. The pattern for a generic Composer looks like this:

How this general pattern translates into specifics for the Grant Composer is shown here:

Two knowledge artifacts are required for a Composer: a document content tree, which contains the raw material for the document to be composed, and a table, which contains the assembly isntructions. 

In earlier posts, I described the Foundation Sequencing Table, which holds the assembly information necessary to generate a grant application. This table will be a community asset that I will build and maintain. There will be only one version of this table because the information requirements for a particular foundation are the same for all charities that apply for grants.

The content to be assembled, however, is unique to each charity; each will have its own business plan, documented using our planning tool. This plan is an asset that will be built and maintained by the charity.

These two knowtifacts, then, are inputs to the composer application. Like all of our applications, the first step in using the tool is to collect the context for the current situation. In general, we run an application to solve a particular problem in the current moment, and the context is the way we describe our current needs. 

The Grant Application Generator needs to collect two types of context information.

The first type is information that helps the application 'prune' down the input knowledge artifacts to the relevant columns, tree branches and fields. Questions like 'which foundation', 'which program' and 'long or short answers' fall into this category.

The second type is specific information that refers to this particular grant request only, and therefore cannot come from the business plan. Information in this category includes the request amount and date. This information must be collected at run-time so it can be filled in at the appropriate locations in the generated document.

Once the context is collected and 'OK' is clicked, the Grant Generator creates a document that meets the specifications: just the information the target foundation wants to see, and in the order they want to see it. (I've grayed out this charity's info, to protect their privacy.)

In my next post I'll discuss some of the details about how this report is formatted, and how charities can use it.

Lessons from the Field: My Initial Experience with the Grant Proposal Content Table

One month ago I began using Microsoft Excel to capture the answers of several small charities in the Content Table that provides the 'raw material' for the Grant Proposal Generator. This Content Table was described in my October 7th post.

As is always the case, the real-life application of tools and ideas surfaces many opportunities for refinement. That is, after all, why we do testing! In the last month I became more convinced than ever of the need for such a tool, and the value it can provide charities. But I learned a couple of important things - one about the need to be filled, and another about execution - that will impact our approach.

First, the need. From the beginning, I approached this as an opportunity to help charities generate grant proposals quickly and easily. We would do this by capturing their answers in a format that could be automatically configured to meet a foundation's requirements. What I didn't anticipate is that the charities would also need help developing those answers. In fact, by removing the impediments to proposal construction, we shone a light more brightly on the quality of the answers that were being assembled.

In other words, by focusing our efforts on capturing the one, best answer to a set of comprehensive, rigorous questions it became clear that those answers often did not exist. Or many versions of the answers existed, in many different documents. What became clear to me is that the first need the charity had was support for the business planning process. Without that, our automation efforts would churn out a high volume of low quality grant proposals.

The second thing I learned is that Excel was not the right tool for this job, primarily because a table is not the best shape for the knowledge we are collecting. The content required is a business plan, and the business plan is best described as a hierarchical model, not a table; it is a triangle, not a square. Here are some of the signs that told me a change in approach was necessary.

First, I love Excel, but it is designed to work with numbers not large blocks of text. Trying to type long descriptions into spreadsheet cells was pure misery! That's okay; I had a more fundamental reason that Excel was not the right tool for the job.

Just as a reminder, this is what the structure of the Content Table looks like:

The table has about 150 rows/questions and two columns for General Operating Support (long and short form), and two columns for each program described in the plan. So, if a charity has two programs they will have a total of six columns.

I said up front that the answers to some of the questions will be the same for GOS and all programs - contact information falls into this category. The mission statement of the organization is another example of an answer that doesn't vary. Multiple columns were required because many other important questions will have different answers for different programs: questions regarding populations served, communications strategy, and volunteer requirements, for example.

It's not until you are actually copying and pasting the same answers over and over that you stop and say 'wait! there must be a better way'. And there is.

The copying and pasting was a sign to me that I was using the wrong shape to capture the necessary knowledge. This was not a list of questions (a 'line') with multiple variations (a matrix or 'square'). It was a hierarchical business plan - a tree or 'triangle'. Some of that information I was copying and pasting many times was high level information that only needed to exist once for the whole organization, and sometimes it was information from a different branch of the tree and didn't need to be duplicated for each 'program' branch of the tree.

I knew I needed to rethink the structure of the content knowtifact. I had picked Excel because it was convenient and familiar, but our own KnowtShare application, which makes it easy to construct hierarchical models stored in JSON (a web-oriented data interchange format) was a better choice. So I went back to the drawing board to reinvent the content knowtifact for the tool we are now calling the Nonprofit Planner. My next blog posts will be about that reinvention process.

Creating the Content Table for the Grant Proposal Generator

My first challenge was to identify the comprehensive set of information items that would cover all the questions asked by foundations in their grant application forms. I started with the most comprehensive single form I could find: the one used by the Catalogue of Philanthropy, a Washington D.C. organization, to vet charities in the D.C. region for inclusion in their publication.

I decided based on my initial assessment that a table was the right shape for this information, and that I would use Excel to create my table.

I used the questions as the row labels, and created columns for the various types of proposals a charity would typically generate.

When a charity makes a grant request they must declare how the money will be used. Is it for general operating support? Or is is for a specific program or project? If it is for a specific program, which one? Once the intended use is declared, all of the following questions must be answered with that end use in mind. Some of the answers, like contact information, will be the same for both general support and specific programs, but many will be very different. To accommodate this variation, I setup separate columns to represent the various versions of the proposals. A charity will fill out a project-specific column for each project that requires funding.

I also setup separate columns for long and short form answers. This is necessary because many online application forms limit the number of words for each response. The approach I envisioned here is that the long form would be written first - it's easier to be wordy - and then a short, pithy version crafted next.

I started with the Catalogue for Philanthropy questions, which are in white. The next application form I reviewed was the Washington Regional Association of Grantmakers "Common Application", and the incremental questions from that were color-coded in yellow. I proceeded in this way, selecting application forms from large foundations, adding any new questions I found and color-coding them to show the source. As I had hoped, after only a handful of forms, the number of new questions dwindled to one or two per foundation. This consistency is important, because it confirms that an automated approach is truly possible! After reviewing five sources, the total number of information items was 130, with about 50 related to financial numbers.

At the same time I was creating the Content Table I was also working on the Sequencing Table, the other knowtifact required for the Grant Composer to work. I'll describe the Sequencing Table in my next post.

Adding Images to the Whiskey Recommender

While images aren't required for a Recommender app, there is a place for a picture in the 'baseball card' template, just as you would expect for any baseball card. Here is an example of the template, as it is used in the Beach Town Recommender:

I want to add images to the Whiskey Recommender, but this is more difficult than it was for beach towns. The challenge arises, once again, because I am working with a much larger set of possible options -- 450 different whiskey brands!

The Beach Town Recommender has about 30 towns in it, so it was relatively easy to search the internet for good medium-sized images of my beach towns and save them to a folder on my computer. I won't be able to do that for 450 whiskeys; it's just too much work. I'll have to find different images for different types of whiskeys, and stop there.

The basic process I used was to (1) locate images using a search engine, and then (2) save those images to a folder using a simple, consistent naming convention. Then I added a "Picture" column to my data table and (3) entered the file name of the image I wanted to display for that particular whiskey.

I started out with a nice, generic picture of whiskey that I could use for my default image. This is the one I selected:

I named this 'whiskey.jpg' and I copied that name into the entire "Picture" column in my data table. I would copy and paste over this name if I found a better/more specific picture.

Now I moved on to my top level classes in my classification tree: American, Scotch, Canadian and Irish. What sort of images could act as generic images for these high level classes?

I learned after doing a bit of image research, which I did in the image section of both Google and Bing, that there were pictures available that showed groups of whiskey bottles, selected to represent different types of whiskeys. Here's an example:

This is the image I decided to use for 'American'. Someone else had already created this for me -- I could see that different bottles had been cut and pasted into the image -- but that's okay, it saved me some time. What I liked about this picture is that it had a selection of Tennessee Whiskey, Kentucky Straight Bourbon and Rye Whiskeys, making it a snapshot of a variety of American types and brands. I found similar images for Canadian, Irish and Scotch. At this point, rather than copying and pasting image names into my data table, I decided to hold off and see what other pictures I could find.

I was able to find similar multi-bottle pictures for several sub-classes: American rye, Kentucky bourbon, Tennessee whiskey, single malt scotch, and blended scotch. I would have liked to have pictures for the other sub-classes as well, like 'American blended' or 'American corn', but I couldn't find anything appropriate. So I used the generic 'American' image for those types, just as I had to settle for only one image for all of the Canadian whiskeys. At this point, I copied the names of the most specific image I had available into the appropriate cells in my "Picture" column.

Now I assessed the situation. I realized that when someone used the Whiskey Recommender, if they were directed to a particular type of whiskey, like single malt scotch, they would see 20+ 'baseball cards' -- all with different information on them but with the same picture, this one:

That's a little too boring, even for a demo! So I knew I needed to push one more level down in the data, if I could.

There were a couple of different options I could pursue. In single malt scotch I had another column in my data table: "Region". I could look for images that went with Speyside, Highlands, Islay, etc. But the other possibility was to look for images that went with the "Company" dimension, images for Diageo, Suntory/Beam, Sazerac, and the like. I decided to look for company-specific images, because that could add visual diversity to all of the whiskey types, not just single malt scotch.

I was able to find images for Beam Irish, Beam American, Forty Creek Canadian, Sazerac Canadian, Diageo Scotch and Pernod Ricard Scotch. Here is the image for Pernod Ricard Scotch:

After adding these images to my image folder, I copied and pasted the image names into the appropriate cells of my data table. I would love to have a picture of every specific whiskey brand, but for this particular demo, I decided to stop at this point. The Whiskey Data Table -- one of the two knowledge artifacts required to create a Recommender app -- was complete.

When I build the Whiskey Recommender using the Recommender Apperator, I will need to upload my folder of images along with my Whiskey Data Table and Context Decision Tree so that the pictures can appear in my web app.

One final comment about finding appropriate images: I always use my search engine's tools to limit the images I am shown to medium-sized files. That is big enough to provide good resolution in my web app, while saving data storage and reducing load times during execution.

Now I need to move on to creating the final 'knowtifact' that is required to generate a Recommender: the Context Decision Tree.

Creating a Whiskey Recommender: The Classification Tree

The whiskey poster I found in an issue of Fast Company (see my last post) showed a complex network of specific whiskey brands and types, but on closer inspection it's clear that it is a single classification tree bound together by class/subclass relationships. There are four major classes of whiskey in this chart: American, Canadian, Irish and Scotch. These classes then break down into sub-classes in a variety of ways, based on the ingredients and process used.

I needed to capture the knowledge from the Whiskey poster in an actionable form, so I used KnowtShare to create a classification tree. This is the American Whiskey branch:

The window in the lower right hand corner is a navigation pane that shows the complete tree.

The KnowtShare app lets me create notes and group them quickly and easily into a hierarchical structure.

The American Whiskey sub-classes are a mix of grain used (wheat, rye, corn) and process (single malt and blended). Bourbon is a unique designation based on both grain requirements (at least 51% corn) and process (charred barrels).

Some of these sub-classes are further broken down based on region and company. The whiskey poster goes on to name specific brands in each of these categories, but with 450 brands listed I opted to stop the KnowtShare tree at this level and handle the brands in another knowtifact: the options data table.

Here are the Canadian and Irish branches of the tree:

The Irish whiskey branch has two new sub-classes: single grain and single pot.

And finally, here is the Scotch whiskey branch:

Scotch is unique because it calls out six different regions for single malt. Each is considered to have its own special taste based on process, but all are made from malted barley.

In KnowtShare, when working with a very large tree such as this, you can use the page itself as the top node of the tree (here it equals "whiskey"). This allows you to arrange the next group of classes in any way that works best visually. The text view will show everything as one comprehensive outline and the .knt file that is saved will combine the four groups into a single hierarchical file.

The next task will be to create the options data table.

Creating a Recommender

I am going to do a series of posts that document the process of creating an app using a knowledge pattern. I am going to use a particular pattern we call a 'Recommender'. The Recommender pattern is shown in both The Shape of Knowledge eBook and in Part 2 of the video series that provides an overview of the eBook's content.

You can view the videos at these links:
Part 1 https://www.youtube.com/watch?v=ui8kjxGmjE0
Part 2 https://www.youtube.com/watch?v=Hma_ho2fHck

The Recommender pattern is made up of one optional knowtifact and two required knowtifacts.

The optional knowledge artifact is a classification tree of the options under consideration. The two required knowtifacts are a context decision tree and a data table that lays out all of the options and their attributes.

In the book I talk about two simple Recommenders: an app that asks a potential knowledge author questions about what they want to achieve and then recommends the best knowledge artifact for the job (the KA Recommender) and a Beach Town Recommender that asks a future traveler a series of questions and then recommends the best beach towns for vacation.

For this example I am going to create a Whiskey Recommender (or "Whisky" Recommender, if you prefer that spelling of the word; I learned in my research that whiskey aficionados feel passionately about this question).

I picked whiskey NOT because I am an expert - I'm not. I picked it because I ran across this great visual in an issue of Fast Company:

This poster, which is very cool looking, appears to be a hopelessly complex constellation of whiskey names and types, but I knew immediately that it was something much more fundamental -- it is a classification tree for whiskeys.

In The Shape of Knowledge, the classification tree is one of my prime examples of the Triangle shape. This whiskey visual doesn't look very much like a triangle, or 'rooted tree', but it is. My first task in building the Whiskey Recommender is to transform this content into a usable form, and I will do that by organizing the basic tree structure shown in the diagram, using KnowtShare.

Relationships ≠ Structure

Here is an image I removed from The Shape of Knowledge:

I removed it, not because it isn't a great visual - it is - but because I didn't want to violate the copyright of the creators. But here, in a blog entry, it falls into the 'fair use' category so I will show it and not just describe it, as I did in the book. This illustration is famous; it did, after all, make the front page of the New York Times!

This diagram was in a presentation made to General Stanley McChrystal, during the time he was  leading the United States' efforts in the Afghan war. On seeing it he is said to have remarked "when we understand that slide we will have won the war".

One of the premises of TSOK is that structure arises from relationships, from connections. The 'materials' cause that Aristotle wrote about is about 'things' or concepts; structure is about the relationships between things or concepts.

My point in showing the Afghanistan slide is that the existence of relationships, depicted by the many arrows in the diagram, does not ensure the existence of structure. A logician would say that relationships are 'necessary but not sufficient' for structure to exist. The absence of structure is what General McChrystal was bemoaning when he made his ironic statement. Here is a visual that 'connects the dots' but no picture emerges.

Sense-making arises from structure, and the best structures for sense-making are those that naturally fit the patterns of relationships our brains make when we are exercising important cognitive skills such as classification and composition. The Shape of Knowledge is about recognizing structure in our thought processes and mirroring that structure in the knowledge artifacts ("knowtifacts") we create to communicate those thought processes.

Knowledge is more than a group of facts or collection of interesting information -- it's knowing how to link those facts together to solve a problem or achieve a goal. Communicating knowledge is about communicating a way of thinking that is useful, and doing it in such a way that others can replicate that thought process successfully in new situations. Creating artifacts to transmit knowledge successfully requires more than domain expertise, it requires an understanding of best practices for creating knowledge artifacts.

I think a good analogy is teaching. A good teacher knows a subject really well: for example, a good science teacher knows a lot about science. But a good teacher also knows a lot about teaching. Teaching is a skill; it can be taught and it is perfected through practice. Creating knowledge artifacts to convey knowledge is also a skill, one that requires an understanding of the role of structure in transmitting knowledge.

The PowerPoint slide above is a knowledge artifact. It was intended to transmit knowledge about the conflict in Afghanistan. It is clear from General McChrystal's comment that it fell short of its goal. Why? How could structure have been used to make its message clearer?