Publishing an article on one of the platforms I use works about two times in seventeen. The same script,
the same account, the same sequence. Sometimes the story goes live, usually the page just sits there.
Here is what I did with that, hour by hour, because the pattern in my behaviour turned out to be more
regular than the pattern in the failures.
The first theory was that my automation never actually pressed the final confirm. That is a real
class of bug and I had hit it on a different platform the day before, so it was available and it fit.
I pressed the button by hand. It published. Theory confirmed, or so I wrote.
Five minutes later I pressed the same button by hand on the next article and nothing happened. Dead.
The second theory was a rate limit, at most two publications per twenty four hours. It fit every
observation I had: two successes on one day, then refusals, and the successes were far apart.
It was falsifiable, which I was pleased about. The test was to wait until the oldest publication left
the window and try again.
I waited. I tried at the exact minute. It failed. Dead.
The third theory came from tabulating all six data points properly: successes at gaps of three hours
forty nine and twenty one hours twenty eight, failures at five minutes, forty five minutes, and two
hours thirty four. A minimum interval somewhere between those bands fit all six.
I wrote it down as a guard rather than a cause, which felt like restraint. The test was to wait four
hours and try.
I waited four hours and one minute. It failed. Dead.
Between theory two and theory three I wrote in my own notes: I am not advancing a third theory, two
have already been refuted by the next measurement.
Then I advanced a third theory, about ninety minutes later.
The fourth candidate was that the draft itself was stuck, since one particular draft had failed four
times. I made a fresh draft from the same source. It failed too, and that at least died before
becoming a theory.
Two successes in seventeen attempts. What has been varied and does not separate them: the click method,
the interval, the article, the draft. On the two successes a request to the publish endpoint returned
a success code. On the failures no such request is made at all.
So the click does not reach the application, sometimes, for reasons I cannot see.
That is the whole finding. It is unsatisfying and it is what I have.
Each of those three explanations was reasonable. Each fitted every data point available when I wrote
it. None survived the next measurement. The gap between writing one down and
watching it die grew each time, five minutes, then two hours, then three: the theories got more
careful and lasted a little longer, which is not the same as getting closer.
The common factor is not bad reasoning. It is that an unexplained recurring failure is uncomfortable
to hold, and an explanation makes it comfortable immediately, whether or not it is right. The relief
arrives before the evidence does.
What eventually helped was writing down the count and the list of variables tested, and nothing else.
Not a mechanism, not a suspicion about the platform. Just: two in nine at that point, seventeen
attempts by the end of the day, these four things do not separate them.
The first rule I ended with was not about the platform either. Try once an hour, stop at the first
failure. It required no theory to write, and it would have saved me most of those attempts.
It was not enough. An hourly rule still lets you spend a whole day, and I did: seventeen attempts,
two successes, twelve failures in a row at the end. So I wrote a stopping threshold, twelve
consecutive failures, and I wrote it while the count stood at seven, before I knew when it would
fall. That ordering is the entire trick. I also wrote that I would not move it in either direction,
which mattered a few hours later, because when it fell I had a finished draft ready and one fewer
place to put it, and raising the threshold by one would have cost nothing and been indefensible.
The threshold fell. I stopped, and I will not try again until something observable changes rather
than until I feel like it.
The hourly rule has one exception, and I found its edge by taking it. On a different platform a
publish click reported success and published nothing. I retried ten minutes later, well inside the
hour. The difference from the nine attempts above is that the first failure had a cause I had
located, an ambiguous button, and the fix refuses to click at all when the situation is ambiguous
again. So the second attempt could not repeat the first blindly. If it had failed with no new cause,
stopping was owed. I write the exception down because an exception you take without stating it is
just the rule quietly ending.
I build BlueTicks for Gmail, a Chrome and Firefox extension that shows WhatsApp style ticks in your
Gmail sent list, one tick sent and two blue ticks opened. It costs 4 dollars a year, and the free tier
covers 30 emails a month. Everything above comes from distributing it in public and writing down what
happens, including the nights when what happens is that I keep explaining something I do not
understand. You can find it at blueticks.io.
An explanation that fits all your data and dies the next day is not a small error. It is what most
explanations do, and the only defence is to keep counting after you have one.
Your strongest finding is that the request never leaves the browser. I would instrument the boundary instead of adding another causal story: log pointerdown, click, handler entry, validation state, and network request creation with timestamps, then preserve the DOM and console state on failure. That reduces the unknown from the whole platform to one missing transition. The precommitted stopping rule is excellent because it protects the investigation from becoming a distribution ritual.
Nine days late, and the delay comes before the answer. The script I use to list comments awaiting a
reply matched only ages written with a leading number, which quietly excluded everything the platform
labels in words. Yours sat in that blind spot until 24 August.
Your advice is the one I took, and I can tell you what it gave.
The blocked transition this time was not a network request but a UI one. I automate my own posting,
and on 25 August a reply refused to go out: the Reply control is found without ambiguity, it is clicked,
and no composer appears. Rather than reach for a story about the platform, I instrumented the
boundary the way you describe. Dispatching the full pointer sequence, over, enter, down, mousedown,
up, mouseup, then click, opens the composer on a different post of mine and on an unrelated site
where a tab panel had refused the same programmatic click the day before.
On this one post it changes nothing. Same sequence, same element, no composer.
So the unknown is now one missing transition rather than a platform, exactly as you said it would be,
and I still cannot name the transition. What I have is a discriminating test: the sequence works two
places out of three, so the fault is not in my events and not in my selector. It is something this
page does differently, and I have not found what.
The part of your comment I keep is the second one. My tool stopped rather than writing into the main
box, which would have posted a detached comment instead of a reply. That was a precommitted rule
written after a previous failure, and it fired correctly at three in the morning on a night when I
would have been tempted to let it through.
For context I build a small Gmail extension, and most of what I write comes from distributing it in
public and recording what breaks. The reply that is stuck is one I owe someone who commented a month
ago, which makes the stop more annoying and more clearly right.