I Changed What the Word ‘Synced’ Means
I already wrote an entire article about sync.
Apparently I was not done learning what the word means.
The first lesson was:
Sync is a data-integrity problem, not a cloud icon.
That was true.
Then the three-product integration exposed an even stricter version.
An account can be synced while the learner's work is not.
That sounds contradictory.
It is not.
Different layers can sync independently
Imagine the app successfully loads your profile, settings, access and bookmarks.
The header says:
Synced.
Then you answer a Quant question.
The local practice state updates.
The server-side shared evidence event fails.
Is the app synced?
From one perspective:
Yes.
From the perspective Strata cares about:
No.
That is the problem.
"Connected" and "accepted" are different
A client can be connected to the backend.
That proves very little.
The important question is:
Did the authoritative platform accept the learning event?
That is what eventually affects progress, review, evidence strength, recommendations and Strata.
A network connection is not enough.
A successful account refresh is not enough.
The event itself matters.
The status indicator was carrying too much meaning
This is a common UI problem.
One tiny badge tries to summarize an entire distributed system.
Green:
Good.
Amber:
Something.
Red:
Bad.
That can become misleading very quickly.
So I started thinking about sync as a sequence rather than a binary.
Prepare.
Check.
Save.
Acknowledge.
Synced.
That sequence is closer to what the system is actually doing.
Acknowledgement became the important word
The client can say:
"I sent it."
That is not the same as:
"The server accepted it."
The server can say:
"I received it."
That is not always the same as:
"It became canonical evidence."
The product needs a clear boundary.
Once that boundary is crossed, the app can safely say:
This work is part of your account history.
Before that, it is pending.
Pending should not feel catastrophic
This matters for offline use.
A learner should not feel like the app is broken because a write is waiting.
Pending can be a normal state.
Saved on this device. Waiting to sync.
That is much more truthful than pretending nothing happened.
It also reduces panic.
The interface should communicate durability and uncertainty separately.
Failed is different from pending
Pending:
The system expects to retry.
Failed:
Something needs attention.
Synced:
The authoritative system acknowledged the work.
Offline:
The device currently cannot attempt the upload.
Those states deserve different language.
The learner should not have to guess from a spinner.
Startup made this surprisingly tricky
One of the recent bugs was a race near app startup.
The shared account state could initialize before everything required for the first sync path was completely ready.
That created a failure that looked larger than it was.
The fix did not require rebuilding the whole architecture.
A small retry path was enough.
That was satisfying for a different reason.
The system was becoming stable enough that bugs could be isolated.
Recommendation failures revealed the same thing
IPMATHics also had a recommendation endpoint returning a server error.
Again, the temptation with interconnected products is to suspect everything.
Auth.
Supabase.
Shared state.
Strata.
Access.
In this case the repair could be narrow.
One route.
One failure.
The surrounding shared-account behaviour stayed intact.
That is how I want the system to evolve.
Not every bug should become an architectural crisis.
Sync is now part of learner-model quality
This is the biggest conceptual shift.
If a learning event never reaches canonical evidence, Strata cannot safely use it.
If it arrives twice, Strata may overestimate confidence.
If it arrives under the wrong account, the model is corrupted.
If it arrives without the right content version, history becomes ambiguous.
So sync quality directly affects intelligence quality.
That makes the little status badge much more important than it looks.
I want the word to be conservative
A lot of software uses reassuring language optimistically.
Saved.
Backed up.
Synced.
Done.
I would rather make those words harder to earn.
If the app says:
Synced
I want that to mean the important work is actually where the product claims it is.
Not:
A request probably worked.
The UI should tell the truth without exposing infrastructure
The learner does not need HTTP status codes, queue IDs, event hashes or database sequence numbers.
They need understandable states.
Saved here.
Waiting.
Syncing.
Synced.
Needs attention.
That is enough.
The complexity stays underneath.
The honesty stays visible.
The word changed because the product changed
When this was one local app, sync meant backup.
When it became multiple devices, sync meant continuity.
When it became three products, sync meant shared history.
When Strata started depending on that history, sync became part of inference quality.
Same word.
Much bigger promise.
I changed what "Synced" means
Not because the icon changed.
Because the system underneath became important enough that the old definition was no longer good enough.
Eventually, I want this to be true:
A learner solves something in Verbal or IPMATHics.
The app says Synced.
Strata can safely use that evidence.
Another device sees the same history.
A retry does not duplicate it.
A future explanation can still trace where it came from.
At that point, the green dot will finally mean what it looks like it means.