Below are images of the first prototype for an actual end-user application I ever built.

When I founded my company, it was to make process flow software for attorneys. The product was called Hammurabi (and no, the Hammurabic code was not exceedingly complex compared to other law at the time, in fact it was a great simplification and clarification). The idea being that there is a limited amount of variation among most cases of the same type. The simplest example we used when the product was conceived was an eviction. There is a very deterministic set of things that happen in Georgia for an eviction to occur. We mapped them on a napkin.

The idea here was to provide a collaborative process flow for each type of case, in which the state of each case was defined in a map. Every stakeholder can monitor the progress of the case at all times, even clients. Once you initialized a case map for a new case, the maps automatically included template documents and forms for the next step in the case at each node, and could be modified to account for variations between cases. Each node in the map contained notes, documents (evidence, briefs, motions, etc.). MS Word is embedded in the UI, the documents are arranged the way attorneys think, the system tracks the work state and progress on each document, and times you as you work, so that we could take the guess work (fudging) out of legal billing.

The diamonds with ?'s in them are decision points, and clicking on them pulls up expert legal advice on what to do, etc. Again, editable. The nodes change color to indicate completion as you navigate the case map and approach resolution, which is indicated (if I remember correctly) by an emboldened outline to a node. The system was also to manage deadlines, contacts, calls, etc. Way too ambitious for a startup (me) without a track record, because it would have taken alot of people to get built. I also had no clue about writing a business plan at the time, so there was no way anyone would give me any money.

The system was supposed to make legal work more efficient, so that you could handle more clients and charge less. Whats more, billing would be more annotated, because what documents and phases of the case were worked on would be automatically in the bill. In retrospect, some unrealistic idealism was going on there.

There are several reasons the system would make lawyers more efficient. The first is that it takes time to recollect what state a particular case is in, because one attorney often handles dozens of cases, and even more that are dormant (and these would take even longer to remember). Whats more, one attorney is not the only person working on any given case. The state map and annotations allow each person working on the case to keep up to date with its progress, even if they haven't thought about it for weeks, months, years. The map presents a user with the most important thing to know: what to do next.

The second is that time spent in billing, adjusting billing, etc. takes time, especially in small firms. The timing system was to reduce this.

The third reason is that the templates and citations present in each node let you attack the next step of a case more efficiently than digging through a network drive looking for a template. Most legal documents are boilerplate stuff, and even if they're not, you begin from a template. You check the same statutes again and again for the same state of each case, with some variations. When these are all linked in a node, its all right there for you. And you can customize these for each case, or for the template, as case conditions, tactics, legal arguments, filings and procedures change. As you work, you improve the knowledge base, building an expert system for your firm.

In addition, the system was to include document versioning like subversion for programmers. Which is the fourth reason that the system allows you to track the status of each document you are working on for a case. When you begin a filing or a brief, you check out the template and move the document (by dragging it, or other means) into the incomplete area of the node. This lets anyone involved with the case know what the status of this process state is. You can rate documents according to their completion with a percentage done bar widget, tag them with tasks for others (paralegals, other attornies) to reach completion, attach relevant citations, etc. When they are done, documents are moved into the complete section.

Some of this breaks down as cases get more complex. I'm not sure this would scale well for multi-million dollar corporate litigation, for instance. Then again, if the tool was robust enough, maybe those types of cases would benefit the most. I don't really know enough to say.

The images here attempt to do... pre-trial motions in the state of georgia, if I recall correctly. We never got them quite right, we ran out of (my) money, lawyers' time is very valuable and so hard to secure for this type of thing on a voluntary basis, etc. and so we decided to do something else. Something we knew about that didn't require us to become legal experts, or to work with inaccessible experts. I've posted these images here before, but never so that they were embedded in a web page.

What follows are images of an Eclipse Graphical Editing Framework/Draw2D prototype of the application. You click on the boxes at right or double click a node to move around in the app. Image two is what happens when you click on a state node in image 1. "Your legal knowledge embedded here..." is what happens when you click on the ? diamond thing. In retrospect, being that we were integrating with MS software, I would do things differently... I would either use the standard MS toolset: .NET, VisualStudio, etc. or do a JS/Flash approach, maybe even ActiveX (ugh). Its just very hard to integrate with office using FOSS, or Java. Ideology blinded me from the business realities at the time. The cool thing about working with Eclipse was that I could not grok how it worked without reading about design patterns, which now help my code not to suck.

Anyway: this is the future of legal software. This was a very ambitious project. Someone will get this right and make a million. That person/group will not be or include me. At the time (2 years ago), I could not find a product, or a combination of products that did this stuff very well, or at all.

Process Flow Software for Attorneys: Hammurabi