Hacker News new | past | comments | ask | show | jobs | submit login

I used to work in a big law firm working on startup-related corporate work. A substantial portion of my job looked like this:

* Find a form or template for a document. Sometimes the "template" wasn't really a template but "we worked on a deal that was pretty similar to this one three months ago -- use that". Sometimes the template was "use this form except for this one section you should use from that form".

* Tag form / template as "version 1" in our document management system.

* Fill in all the blanks, remove brackets, etc.

* Tag this as "version 2" in our document management system.

* Create a diff / redline with all my changes.

* Send diff to partner for review.

* Incorporate changes from partner into document.

* Replace (rather than append) "version 2" in our document management system with the new doc.

* Email document to opposing counsel for review.

* If we're sharing docs with opposing counsel via Dropbox, Box, etc., upload there too. But also email them, because they might not remember to check Dropbox.

* Bug opposing counsel every 24-48 hours until they respond with an edited copy of our document.

* Let partners and clients know that you are bugging opposing counsel so they know it's totally not your fault if this deal doesn't get done by Friday.

* Save opposing counsel's edited document as "version 3" in our document management system.

* Create a diff of the document they send and ask partner to review.

* Bug partner every 24 hours until they respond with more changes.

* Save this as "version 4" in our document management system.

* Send this, along with a diff, back to opposing counsel.

* Somewhere in this process we also pass along to our actual client for review.

* Repeat until no one has any more changes. Do this for many more documents that are part of the same deal.

* Send out the first set of documents for signature. Some people don't want to actually review the things they're signing (crazy!), so we create "signature packets" where it's just like four signature pages in a row. Also, everyone has a different set of documents to sign so different people get different sets of pages + documents -- and sometimes we need to make sure that person X doesn't see some document that only person Y can see because secrets.

* Or we use an e-signature service, in which case I spend some time creating little boxes over all the document so the service knows that this is a place where a signature-like image has to go.

* Discover some error in document. Fix. Redo all of my little boxes.

* Respond to people confused about how e-signatures work. Sometimes if there are four documents, the signatory gets four e-mails and then they're confused as to whether they should just sign the last one or all four or whatever (you should sign all four). Also, sometimes people refuse to use e-signatures, so we have to explain to people that because Docusign says the deal is done doesn't mean it's actually done.

* Sometimes this is where we file stuff with the state government.

* Send out a second set of documents of signature. We don't send these out with the first set (even if the same person is signing stuff in both the first and second set) because it's very important that the second set not be signed until after the first set is signed by all the parties (or after we get some sort of confirmation back from the government if there's a filing involved). Sometimes we have very important people that hate being interrupted to sign documents, so we let them sign everything in one go but hold some of those signatures "in escrow" so we can "release the signatures" in the right order.

* Track all of the outstanding signatures and filings via a spreadsheet and try to update this in as "real time" as possible.

* Respond to partner or client asking you about deal status by pointing to spreadsheet.

* Respond to partner or client unable to open spreadsheet for whatever reason by summarizing signature status in text form.

* Bug people periodically until everything is signed.

* If any of the parties to a deal refuses to e-sign stuff, this is where I have to create a "final" signed PDF copy of the documents, wherein I replace blank signature pages in a document with some faxed or scanned signature page.

* If signatures were being held "in escrow", bug the people who are holding the signatures in escrow for confirmation that the signatures are released.

* Sometimes these people need to bug other people for confirmation. These people then ask lots of questions like "has other person X signed yet?". Point to spreadsheet.

* Sometimes money gets wired here. Wait until we confirm the money came in.

* Signatures are released! The money came in! Tell everyone the deal is done!

* Curl into fetal position.




This sounds painful, but it also sounds fairly typical. Except usually such work is split between several different people/positions.

No one thinks about it, but one of the main reasons this kind of stuff stays manual is because the typical tools people are using to do it have no (good) integration points. Automating the entire process would require writing a large and complicated system. Automating parts of the process one step at a time is extremely difficult, because implementing most of the individual "steps" will require creating tons of complex integrations, and not result in any immediate productivity gains. Such incremental changes disrupt what people are currently doing and possibly create more stuff for them to do in the short run.

For example:

"Fill in all the blanks, remove brackets, etc."

This is a perfect use case for machine learning or even a simple rule-based system. If you had all the data in one place, it probably would be trivial to automate. However, getting all the data from various systems, converting it to a standard representation, then converting fixed data to target formats and putting it into target systems is orders of magnitude more difficult than the actual corrections/changes.


Basically, you need a workflow engine.

Model that process on the engine, the engine takes care of everything else; notification, queueing, etc.


That sounds.... painful...

Totally does seem like something that can be nicely automated to some level. Even document tracking and associated metadata (like a list of participants and status of signatures per page, approval of document, etc) would help.


Of course it can be automated. The problem is that everyone involved in the process is extremely resistant to automation because clients are billed by the hour and automation would result in fewer hours spent on the case, which means decreased revenue.


I'm a total outsider to this field, so forgive me if the answer to this is trivial/obvious, but why not sell a service like this directly to the client?


If you give outside counsel any significant role in a transaction, they'll find some way to create work and bump the bill up to whatever cap you set. So you don't really save cost-wise unless you're able to almost entirely remove the human element.

Now as to why we don't remove human lawyers from the process ... I think it's trust, mostly.

It's a bit like selling automated medical services. Your clients don't always have benchmarks for what's "good" legal work, much in the same they don't know if they're getting "good" medical advice, so it's hard to evaluate the quality of an automated service. And since there's always some chance the automation misses some edge case that a trained professional would have caught, if the stakes are high (medical -> life or death of a person, legal -> multi-million dollar lawsuit), clients opt to keep the lawyer (or doctor) in the loop.

For simpler or low-stake workflows though, there is direct selling to the client (see Clerky).


100% accurate. I did the same and also quit.


Holy. Crap.


thats like how a compiler works, except for english word docs.




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: