According to this chart, they should have asked me for biometrics and medical before sending the SA letter. My wife got the SA letter ( a few days ago) and in it they said my file is being moved to London (London didn't contact us yet). They also mentioned to contact them for all further communication.
They already have my biometric on file from my previous visitor visa. So I can understand them skipping that part. But what about medical?
It's only been a few days, just wait.
It's clear they've been modifying the processes somewhat - notably that these requests are often coming slightly out-of-order (from what was before and also from what is in your flowchart).
As someone who has worked with flowcharts a bit
like these, and have fought about with people who designed them, the flowchart has strict serialism vs parallelism (implied anyway). The biometrics/medical/SA letter are a good example - they're depicted here as first one
is completed, and only then can the next one start (serial, one by one). There's no reason the file can't be sent to a visa office in the interim, actually.
Parallelism is they are all just done at the same time - or more accurately, completing one task is not required to do the next, so the process doesn't stop if these different tasks are not time sensitive and are working at different speeds. It
does mean that the exact precise order isn't followed - but that's also irrelevant (in this case). Instead, a task request (eg to prepare and email the medical request) is sent internally, and then move on to the next box on the flowchart without waiting.
[For those who've done computer programming, it's a lot like moving tasks out of the 'main program' and into subroutines, that can have their own dedicated resources/processor time.]
This may sound either geeky technical or completely obvious (depending on the reader), but I've seen how these organisational task flowcharts get implemented, and the implementation team will often do exactly what the flowchart says unless they're told not to. An example I've dealt with is a process that needed ~ten human approvals or sign-offs, and the process would literally send the 'task' to those ten people in strict order, and any one of them delaying would slow everything down; switching to requesting the approvals simultaneously made a big difference. The downside is that this parallelism requires new/different logic to reconcile errors and issues and to check that the other tasks are complete. It's a lot easier to do with computer code than human beings (who really thought it was important that the precise order be followed, because it was hierarchical, and they didn't want to deal with disagreements).
