The “No-Code Intranet” Myth: Why Legal IT Still Pays to Make Small Changes
The “No-Code Intranet” Myth: Why Legal IT Still Pays to Make Small Changes
A Knowledge Manager at a 400-lawyer firm wanted one simple change: a page for the firm’s new practice group, visible only to that group and firm leadership.
The vendor had sold the intranet as “no-code,” which meant the firm’s own team should be able to make changes without writing software code or relying on developers.
The firm’s IT team knew how to create the page and had the technical skills to manage its permissions. But the intranet did not give them access to the settings needed to make that change. The page structure and permissions were controlled through the vendor’s proprietary system.
So instead of creating the page themselves, the firm had to submit a vendor request.
Six weeks and a five-figure invoice later, the page went live.
The firm’s IT team could have handled the request that same afternoon. The problem was not their ability. The problem was that the system did not give them control.
Most legal IT leaders see this pattern repeatedly. The specific request may change each time, but the process stays the same.
That raises a simple question: if your own IT team still needs the vendor to make routine changes, how “no-code” is the intranet really?
What No-Code Was Supposed to Fix
The idea behind the no-code is simple.
Instead of writing custom software every time something needs to change, users can use visual, drag-and-drop tools to configure the system themselves.
Outside legal, this idea has already become mainstream.
Figure as reported by the source named on the card.
In simple terms, many people building business tools today are not professional developers. They are the people who understand the business and use those tools every day.
Why Legal Firms Rarely Get the Real Thing
Legal technology spending continues to grow.
Figures as reported by the sources named on each card.
But not all this spending is going toward new software.
Some of it goes toward paying vendors to make changes that the firm's own IT team could otherwise handle.
The issue is how the intranet has been designed.
In many systems, page layouts, permissions, and data connections are controlled through proprietary configurations that the firm's IT team cannot access directly. The vendor may provide a simple interface for certain changes, while keeping more important controls behind its own configuration layer.
That creates a gap between what “no-code” promises and what the firm can actually do.
So, every small request becomes:
The code may be hidden from the firm's IT team, but that does not mean the firm has truly been given control.
What a Real No-Code Intranet Looks Like
Legal firms have an important reason to be careful here: confidentiality.
Different practice groups may need access to different information. Client matters may require strict confidentiality of walls. Permissions need to reflect roles and responsibilities accurately.
That means “let anyone change anything” is not a safe approach for legal.
But strong security does not mean every change needs to go through the vendor.
A well-designed no-code intranet should allow the firm's own IT team to make routine changes directly, while keeping appropriate security and governance controls in place.
For example, IT should be able to:
- Create practice group pages and role templates using simple, familiar structures instead of a proprietary configuration language.
- Manage permissions in-house, with a clear record of who changed what and when.
- Connect new research platforms or case databases through visual, point-and-click configuration rather than custom code that only the original vendor can maintain.
The goal is not to remove IT from the process.
IT should remain in control.
The goal is to give IT the ability to make changes the firm needs, when the firm needs them, without turning every small request into a vendor project.
A Simple Test for Any CIO
Before renewing an intranet or knowledge platform, ask one question:
That question quickly separates a genuinely flexible no-code platform from one where “no-code” mainly means the firm does not have to see the code.
