Update Shared Treatment Copy Without Overwriting Local Layout Edits

An update you can trust is one you can describe before you run it. Three parts: the change that's arriving, the local difference that won't survive it, and the copy you can restore if you're wrong about the second part.

The second part is the one that gets skipped. The update runs, the shared paragraph comes back in the parent's wording, the layout reflows, the link panel reports nothing wrong. Then someone notices that a line has gone back from "customer" to "performer," and the crew is casting an actor for a shoot that was approved with real people in it. Nothing crashed. Nothing was flagged. A decision was undone.

The mechanism is worth understanding on its own terms, because the way people talk about links encourages the mistake.

The link is a dependency, not a permission

Adobe's help page on linking and updating content across documents states that a source item acts as a parent, that linked items can be updated, and that local edits can be overwritten when they are replaced by the parent version. Checked September 2026, the page warns about replacement and does not promise that any particular local formatting survives.

Read that for exactly what it is: a description of propagation. It tells you the parent's version can replace the local one. It is not a statement about who is allowed to change the film, and it is not an assurance that your column breaks, your re-condensed sentence, or your deliberately short line will come through intact. The warning is narrower than people remember it being, and that narrowness is the whole problem.

Two things need to be true before you touch anything.

The parent has an owner. Some person can say, "the shared text now says this, and that's agreed." If nobody can, you have a different problem than the one this article solves.

You know how far behind your copies are. If it's ambiguous which revision of the parent a placed copy was last updated from, treat the next update as carrying everything that changed since — not only the change you have in mind. The one you're thinking about may not be the only one arriving.

Three kinds of local difference, and only one is formatting

Fit. Manual line breaks, a sentence condensed to sit in a fixed strip, a narrower measure. This is what people mean by "formatting," and the label does more work than it deserves. A sentence shortened to fit can carry the same facts with a different emphasis, and emphasis is part of a treatment. It isn't a change to the proposal, and it's usually cheap to redo — but "usually cheap" is a judgment you make after looking at the strip, not a property of the category.

Meaning. The word that names who is in the scene, what the product does, whether the thing is a demonstration or a performance. An update that reverts one of these doesn't produce a formatting fault. It produces a document that is wrong in a way nothing will announce.

Proposal. The local editor solved a shared problem locally. This category gets forgotten, and it's the most useful one, because the right move isn't to protect the exception — it's to send it upstream. A local difference that is better than the parent isn't a divergence to preserve. It's a revision waiting to be authorized. Do that and your exception list gets shorter every time. Skip it and you accumulate documents that each quietly disagree with the master.

One passage, three places

The set below is invented — a fictional sixty-second brand film with a fictional parent treatment and three fictional placed documents. I haven't built these files or run an update against them. What's documented is Adobe's warning about overwritten local edits; what isn't documented, and what I can't promise you, is how any particular local formatting exception fares in a given version. The names here exist to keep the reasoning honest, not to describe a project.

The shared passage lives in the parent, Treatment_Master.indd, as "Scene 2 — The counter." The authorized wording reads:

Scene 2 — The counter. A performer works the counter alone. We stay on her hands: weighing, sealing, writing the order number. She never looks up.

That's the revision the other three documents were last updated from. The parent then changes once: a final beat is added, so the current parent reads:

Scene 2 — The counter. A performer works the counter alone. We stay on her hands: weighing, sealing, writing the order number. She never looks up. And then, once, at the end, she does.

One added sentence. Watch what it does in three places.

The shoot deck (Shoot_Deck.indd) carries the passage in a fixed-height strip beside the storyboard frames. The strip holds four lines at the deck's body size, and the designer made the text fit — manual breaks, plus a condensation of the middle sentence:

Scene 2 — The counter. A performer works the counter alone. Hands only: weighing, sealing, writing the order number. She never looks up.

Two differences are stacked here. The line breaks are obvious. "Hands only" for "We stay on her hands" is a change of emphasis, made for a formatting reason but not identical to the formatting reason. An update to this copy replaces both, and the parent's fuller phrasing is longer than what sits in the frame now. The strip ends up with more text than it can hold: an overset, or a frame pushing into whatever is set below it. Nothing about that is mysterious. It's work you have now created.

The call sheet (Call_Sheet.indd) carries one changed word.

Scene 2 — The counter. A customer works the counter alone. We stay on her hands: weighing, sealing, writing the order number. She never looks up.

The client decided to film real customers instead of actors, and the person who prepared the call sheet wrote the decision into the copy she owns. The parent has not been told. An update here would bring the parent's added final beat with everything else — one more line in a flowing document, no reflow, no overset — but the word is the arrival that matters. It replaces the local "customer" with the parent's "performer," and nothing in the layout announces it. The crew casts from this document.

The leave-behind (Leave_Behind.indd) has no local difference at all. It also shouldn't move on the same schedule. The layout is approved, the PDF has gone to the client, and editing the source file now would mean the file no longer matches what was sent.

Same parent change, three different problems: a reflow you can fix, a fact you can lose, and a document that shouldn't move yet. Which is why the update policy can't be one policy.

Link, copy, or freeze

Three routes. The honest comparison is about what each one makes you do afterward.

Ongoing linkage. The child follows the parent; updates are deliberate and applied one document at a time. You get propagation without retyping. You pay in overwrite exposure — every local difference sits under the parent's next revision — and in re-application, because exceptions you keep have to be rebuilt after an update.

Independent copy. The child is its own text. Nothing propagates; nothing is destroyed. You pay in bookkeeping: somebody has to notice the parent changed and decide, per document, whether the change applies. That cost is invisible until it isn't, and it grows with the number of copies.

Declared freeze point. You name a baseline — this approved revision, this wording — and copies are maintained separately from it until an agreed trigger says otherwise. It's a policy, not a mode; no panel enforces it for you, which means the baseline has to be recorded somewhere a person will actually find it. Its cost is drift: a frozen document now differs from the master on purpose, and that purpose needs a name. "It's at the approved revision by decision" is a policy. "It's at some revision, we think" is a future incident.

Read the table by the row that hurts you. If shared passages change often and the local differences are mostly fit, linkage earns its keep. If the shared text is stable and the divergence is deliberate, independent copies cost less than the re-application. If a document is approved, exported, or locked, freezing costs you nothing you weren't already going to lose.

But the route decides who propagates. It doesn't decide what's true. A linked document that is up to date can still say something nobody approved, and an independent copy can be three revisions stale. Both look current from inside their own systems.

Applying that to the fictional set:

• Shoot deck: linked, with the condensation written down in the file as an exception to re-apply after each update, and a note that the strip's height is the constraint, not the wording.
• Call sheet: reconcile before doing anything.
• Leave-behind: frozen at the approved revision, with the trigger named.

The call sheet is the interesting one, because the fix isn't in the software. If the real-customer decision is authorized for the treatment, the parent is wrong rather than the call sheet, and the right move is a parent revision. Adopt the word upstream and one permanent exception disappears — the parent now says "customer," the local difference stops existing, and the call sheet can be linked like anything else. Leave it and you'll have this same conversation at the next parent change, and at the one after that.

Reconcile before you press Update

In order.

1. Know what the parent currently says and who authorized it. Not the wording you remember from last month. The wording that's there, plus the fact of agreement.
2. Keep a restorable set. Parent and children together, before you start. Duplicating one file is not a baseline: restoring the parent alone leaves you with children describing a state that never existed, and restoring one child leaves you with a copy that belongs to no revision of anything. Copying the whole set is cheaper than reconstructing it.
3. Name the arriving change out loud. "The parent added the final beat." If you can't say it in one sentence, you don't yet know what the update will carry.
4. Classify each local difference: fit, meaning, or proposal.
5. Decide per difference: propagate upward, re-apply after, preserve independently, or let go. Write the decision where the next person will look, which is the file, not your sent mail.
6. Update one placed passage at a time. The point of doing one first is that you learn what your version actually does before you've done it everywhere.

That last item is where the caution belongs, because the documented warning tells you that local edits can be overwritten without telling you what "overwritten" looks like for any specific exception. Whether your line breaks survive, whether the frame oversets silently, whether the panel changes state at all — those are properties of your file and your version, and the only reliable answer comes from a copy you're willing to throw away.

Test one passage and read the result

What follows is a checklist rather than a transcript. I haven't run it against these files, and menu names and panel behavior shift between versions; confirm the labels in yours rather than trusting a remembered path.

Make a disposable copy of the parent and one child — the shoot deck is the right one, since it holds an exception you're expecting to lose. Establish the link from the parent into that child using whichever route your version provides for placing linked content from another document, then find the placed item's status in the link panel before you change anything. You want to know what an untouched, in-sync child looks like so you can recognize the other state afterward.

Then change the parent once, in a way you can identify instantly. Add a marker you would never ship rather than rewriting a paragraph. Update only the trial child.

Read four things, in this order.

Meaning. Does the child now say what you expected? Read the sentence, not the panel. A successful update is not an editorial acceptance; the operation can complete cleanly on a document that now states something nobody approved.

Deliberate formatting. Are the line breaks yours, the parent's, or the application's? Whichever the answer, you now have one instead of a guess.

Fit. Look for overset, a strip that has grown past its frame, a paragraph that has pushed text below it. Reflow is normal. Silent reflow is what reaches the client.

Saved state. Save, close, reopen. Confirm the file on disk is the one you think you tested, and confirm how you would get back. Undo may or may not survive the operation depending on when you notice and what else has happened since; treat the duplicate set, not the undo stack, as the baseline you would actually restore from.

One limitation, stated once: this is InDesign's model for placed content from another document. Word, Figma, and every other tool with a synchronizing feature have their own rules about what a link preserves. The reasoning here transfers; the mechanics do not. Don't carry a behavior observed in one application into another.

What to write down

For the fictional set, the policy that falls out looks like this.

The parent is Treatment_Master.indd, owned by the treatment owner, and only that person authorizes wording in the shared passage. The call sheet's "customer" goes up, because the decision is real and the shared text is the wrong place for it to be missing. The shoot deck stays linked, with its condensation recorded as an exception to re-apply. The leave-behind is frozen at the approved revision by decision, with the trigger named: it moves when the treatment owner signs a new revision for the client, and not before.

That freeze produces a mismatch worth seeing plainly. Once the parent says "customer," the sent leave-behind still says "performer," because that is what the client approved. The freeze is what keeps that difference visible and assignable instead of letting an update quietly rewrite the file so that it matches nothing the client ever received. The recoverable baseline is a dated copy of the whole set — parent and all three children together — taken before the update. If the update does something the checklist didn't predict, that set is what you restore, and the cost is a few minutes instead of an explanation.

The rule for next time is the only part that needs to be memorable. Before you press Update, name the change that's arriving and the difference that won't survive it. If you can name both, the mechanism is doing exactly what you want. If you can only name the first, you're about to learn the second the hard way.

The lesson isn't "never link." Linkage is why one authorized sentence in the parent becomes one authorized sentence in four documents. The lesson is that the operation is mechanical and the decision isn't — and that the gap between them is where approved treatments change meaning in silence.

Frequently asked questions

What two things should you be able to name before pressing Update?

The change that is arriving and the local difference that will not survive it. If you can name only the first, you are likely to learn the second the hard way. You should also know the parent wording, its owner, and have a restorable baseline.

Does a link give permission to change approved wording?

No. A link is a dependency, not a permission. The parent's version can replace the local one, and local edits can be overwritten; that describes propagation, not who may change the film. Parent wording still needs an owner who can authorize it.

What are the three kinds of local difference?

Fit, meaning, and proposal. Fit includes manual breaks or a sentence condensed to sit in a fixed strip. Meaning includes a word that names who is in the scene or what the product does. Proposal is a local solution better than the parent and should be sent upstream for authorization.

What tradeoffs come with ongoing link, independent copy, and declared freeze point?

Ongoing link propagates parent wording but exposes every local difference and requires re-applying exceptions. Independent copy destroys nothing automatically but requires manual comparison and propagation. A declared freeze preserves an approved revision but creates intentional drift and needs a named trigger and person to enforce it.

What should happen when a local copy contains an authorized fact the parent lacks?

Reconcile before updating. If the decision is authorized, the parent is wrong, so the right move is a parent revision. Adopting the word upstream removes a permanent exception and lets the local document be linked like any other.

Further reading

• Write and Design a Treatment Together Without Losing the Current Version — Read this first when nobody can say who owns the shared wording; it sets up the ownership and one-current-meaning agreement any update assumes.
• Lay Out a Commercial Treatment in InDesign Without Losing Copy Between Pages — If the update leaves the shoot deck's strip overset, this explains why threaded and unconnected frames hide or reveal copy, and how to repair space.