Democratic governments around our big blue marble are considering upgrades to their legislative IT systems.
Deciding what to upgrade is fun. We get to use white-boards, talk to users, research emerging technologies, and everyone gets excited about creating something together.
Deciding how to upgrade will make or break your project.
The What
Most democratic governments follow similar protocols to amend and manage law:
- The body of law that has already been enacted (unless you’re starting a new country).
- Intention to change or amend the law is proposed by someone.
- Experts draft an amendment according to the intention.
- The draft amendment is then studied by committees and individuals to evaluate consequences.
- The Clerk publishes the drafted amendment for public review and comment.
- Voting on the draft amendment is conducted according to the rules of body for approval.
- If No, the draft is dead.
- If Yes, we have a new law.
- If the draft amendment is passed, it is law. It will be published again to the public and consolidated into the body of law for transparency.
The individual parts, jobs to be done, and processes create our system of lawmaking and stewardship.
Technology gets old. So we need new software to support our systems of lawmaking.
Thinking in systems is critical. So, what is a system?
A group of interrelated elements that interact according to a set of rules to form a unified whole.
Another complicated system we all rely on is the Internet. The Internet system is lot of interrelated elements which are all tied together by well-defined and standardized protocols or sets of rules.
You are reading this in a web browser. You can switch to another web browser and the content is interoperable. Upgrade your web browser? No problem (if the protocols are implemented correctly).
Protocols (also called standards) separate the application (a specific software implementation) from the content (also structured according to the protocol). This means you can replace old applications and the system continues to function.
When a legislative system is tied to a specific application and a proprietary content structure (like MS Word), that legislative body is subject to the application and is stuck. You cannot replace failing parts of aging systems. This is not an acceptable situation; governments should not be held captive by proprietary formats and the for-profit corporations who peddle them.
In every democratic government, there is a legislative protocol. These rules are written into our founding documents and they govern how we change laws. These rules rarely change.
There is also a software protocol designed specifically to support legislative protocol.
LegalDocML. This is the law’s equivalent to the IEFT protocol that made web browsing possible. It is an open standard which allows for the capture, storage and communication of information. To create a modern legislative system, LegalDocML should be adopted as the primary method for interconnecting all the various parts of the legislative process. Both content structure and application software should follow LegalDocML.
LegalDocML creates the foundation of a modern legislative system; gives it life.
Drafting, workflow, publishing, consolidation and many sub-steps are addressed by LegalDocML and empower better applications than most governments are using today.
You have upgrade opportunity all around; creating value for users along the way.
There are lots of pieces in the “what”, but to create a modern system there must be a way to connect different elements. The starting point for any upgrade to a legislative system is LegalDocML. Fail to do this, and you are doing it wrong.
The How
If your new system will utilize LegalDocML, you’re starting in the right place. We can now move forward with modern software engineering and practical decisions about budget and aging systems.
The “how” is also designed to tell us how to prioritize the “what”.
Just like Firefox is an application that implements the HTTP protocol and relies on structured content to be useful, you’ll build applications that implement legislative protocols like drafting, publishing, and consolidation which rely on structured content (LegalDocML).
First steps…
Collaboration and User-Stories. The first part of “how” is to listen to users and smart technical leaders. What is broken? What is causing problems? What is inefficient or frustrating? What could be better? What risks does the aging system create?
Listen to users and collect their stories. After the above is documented and analyzed, only then should we move to solutions. Humans are funny, once a solution is promoted the innovation begins to diminish.
Once you’ve listened, then people will trust you enough to truly collaborate. Collaborate and imagine what life could look like; what an ideal system would do for them and for the whole legislature. Collaboration is the fun part.
In software circles we talk about “waterfall projects” vs “agile projects”. A waterfall project spends months (or years) designing big projects and then attempts to implement tons of code before getting that valuable feedback. It is theory first, then huge investments, then feedback.
You can literally build a waterfall system that is old and outdated before users even see it.
Agile projects seek to deliver code within a system quickly. Leave the advanced features and edge-cases for later.
Prototype, Test, and Improve. Only when you have a true system built on a defined standard is this possible. If your information structure is LegalDocML, then you can prototype publishing without creating damage to other parts of the system. You can prototype and test consolidation in various ways.
Prototypes should be lightweight, fast to build, and implemented immediately.
The goal is to get something quickly into the hands of real users. Why? Feedback!
“This worked!!”
“That didn’t…”
“I have another great idea!”
“That didn’t create the value we thought it would…”
With LegalDocML in place, you’ve created something incredibly value… a platform to build, test, and iterate on new applications for real users. The law and legislative protocols are unchanged, but your software can be tested, discarded, and renewed.
Being agile is smart. It is cheaper, delivers more innovative features, and in the end makes users happier. Agile projects focus on high-impact / low-effort items first and avoid low-impact / high-effort work; the value is obvious.
Summary
You may need to replace the whole software system, because some legislative systems are 20+ years old today.
Building your new and future-proof system starts with LegalDocML as a foundational. And when combined with an Agile approach, you can build a new legislative system with replaceable parts.
And of course, Xcential is here to help.
