My passport has gone for police verification. What’s next?

The obvious answer is that wait for the local police station to call you. However, for how long and how to track its progress? I am here to throw some light on that.

Even if you have opted for SMS and email updates, passport department seldom sends any updates. The best source of finer status updates is login into their official portal from where you filled and submitted the application. Choose the same login and select the submitted application. You will notice an option to track status.

While it is with the local police for verification, the status here will say something like – It is sent for physical verification at XYZ station, and might take around three weeks. If you live in Hyderabad’s Cyberabad area then you can also track progress on the police side from

This will provide info if they have received the request for processing or not. In our case we got a call from Cyberabad police after two days and then they came to our home for physical verification. They simply asked for the passport application form and related docs, and of course they physically met the applicant. Next day on the same portal we got info from the same portal that it has been processed by them and the report has been sent to RPO (Regional Passport Office). It does not specify the kind of report they have sent – Clear or Adverse. Adverse is bad, and might result into application rejection.

In a day or two the status on passport site should then change to something like – Report from XYZ police is under review at the RPO and if found clear, the passport would be sent for printing.

Finally after two three days if it updates to say something like – The passport has been sent for printing, then congratulations the police had sent clear report and your passport has been approved. After few more days again the new passport number and the Speed Post tracking number should be listed. At this point of time you should also receive an SMS for the same. In total the whole process took around 10 days.

If during this entire process if it looks like the process has got stuck somewhere, schedule an appointment for enquiry at the PSK from the official passport portal. All the best!

Registering a new car in Telangana RTO in 2023

The dealer takes care of paying the RTO fees and getting a temporary number. Then they tend to handover to an agent for slot booking and getting the permanent registration number. I was asked Rs. 3000 for this. I asked around, some were asked Rs. 1500, etc. fees. I decided to do it on my own as my RTO (Kondapur RTO) was quite near to me.

Slot booking

  1. Goto
  2. Enter the requested details. On entering the OTP, applicant’s details will be shown below. Submit the page to book the slot. No fees will be charged.
  3. Take a print out of the slot booking confirmation.
  4. From the dealer do collect the following documents. They usually give that to the agent, so do ask for them and positively collect it from them.
    • Form 20 (2 copies)
    • Form 21
    • Form 22 (This is provided by the car manufacturer. Do not loose this as getting a duplicate of this will be very very difficult and I was told it could take months.)
    • Insurance Certificate
    • Invoice from Dealer (You might get 2 copies of this as well. Keep one copy with you.)
    • Life Tax Receipt
    • Temporary registration certificate
    • Car price sheet (Tick the exact car model bought by you. RTO uses this to cross-check the life tax amount.)
  5. Along with the above you will also need.
    • Valid address proof, like Aadhaar card, passport, etc. You must carry their original and a self attested copy.
    • Pan card (Original and self attested copy)
  6. Keep a pen and a pencil with you. (Yes a pencil too. Must have.)
  7. Ask your dealer or check online to figure out where your car’s stamped VIN is located. It should be etched on some metal, not merely printed.

Visit the RTO

  1. On your chosen day visit the RTO. You would have chosen a date and time. Ignore the time and just go early as it is going to take quite a while. And do take your car which is to be registered along with you.
  2. Park the car and goto counter where the new vehicle registration documents are submitted. Ask around for that. Usually there will be a board on that counter which would announce that and a list of documents to bring. In our case only four – five people were in the line and the agents were using the back door, carrying with them a thick bundle of documents of various clients. It took around 20mins here since for each person all the aforementioned documents has to be cross-checked by the RTO officer. After successfully completing this step he will hand over a small slip with application number and the fees collected. For us, weirdly it mentioned a slew of different fees on it and at the end said, money collected is zero. And surely no actual money was collected!
  3. Next is getting your picture clicked for the RC and specimen signature. This was a huuu…ge line. We thought easily it would take one or two hours. Fortunately, in my case, it was my wife’s car and for ladies there was a separate line of only two people. We were done in five minutes.
  4. Next and final is locate the hut where policemen are seated and get the car inspected by them. On both copies of Form 20’s end you will need to trace the car’s VIN number using the pencil (video). Be careful to not tear the forms in the process or move the form so much that the trace is illegible. Take the traced forms to policeman, who will verify the VIN and you are done.

Checking for status online

Periodically check on It could take a while to be updated. It will provide details like when the application gets approved, RC gets printed and dispatched. It will also provide the India Post tracking number. The provided India Post tracking number may not work for few days after the dispatch date. Your RC will arrive at your home address, but the number plate will goto the showroom. The dealer will install that at the showroom.

I did not receive any SMS updates and the number plates arrived before the RC. You can use M-Wallet app to virtually download your RC.

Agent v/s Own

Via Agent5mins (on 1st window) + 5mins-120mins (on second window. You will have to get in line here) + 15mins (the policeman will come to you and the agent may or may not help you to get the trace) = 25mins-140minsRs. 1500 -Rs. 3000
Own20mins + 5-120mins + 15mins (you goto the policeman and since 90% people take help of agents, so this person will usually be sitting all alone :P) = 40mins-155minsZero

Take your pick!

Starting OnePlus Android phone when its power button is broken

I have an ancient OnePlus 6 which my son uses for watching cartoon. Recently its power button stopped working and my son drained its battery until it shutdown. Fortunately its volume buttons are still working.

For this you will need a laptop and a USB-C cable to connect the phone with the laptop.

  1. Ensure the phone is charged.
  2. Remove the cable from the phone.
  3. Press the volume down button. Keep it pressed.
  4. While keeping the button pressed insert one of the of the cable into the phone and the other end in the charger or laptop or power bank.
  5. Still keep the volume button pressed until you see something on the screen. Then release the button.
  6. You will now get into phone’s recovery menu. Some versions of One Plus and other Android phones have restart option right here. If yes then choose that and you are done. – Else continue below –
  7. In my case; in OnePlus 6; I had to choose Advanced option and within that it had “Reboot to fastboot” and “Reboot to recovery mode”. Choose “Reboot to fastboot” here. But wait!
  8. First goto your laptop and install ADB tools from Google. Choose one from the following based on your laptop’s operating system.
  9. Extract the contents of the above zip file. Now choose the “Reboot to fastboot” option on your phone. Without this you will not able to turn on or off your phone until it runs out of battery since this mode requires the use of power button to confirm the selection.
  10. Connect the phone to the laptop using the cable then go into the extracted zip file’s directory and run ./fastboot devices to confirm that your phone is detected.
  11. Finally run ./fastboot reboot this will respond with a “Ok” response and your phone will reboot into normal mode. Congrats!

RunPage tech overview: AWS Textract integration

RunPage now supports two new APIs


As their name suggest they can convert any provided image or Pdf files and use AI to extract Danfo DataFrames from them!

Checkout below for a demo of it:

AWS Textract

The AI intelligence is provided by Amazon Web Service’s Textract service. This service accepts image and Pdf binary data and returns a whole host of meta data, like the individual words, lines etc. It can also recognise Forms and Tables, of which only the Tables recognition capability is used.

I also checked out competing product from Google – Document AI. The result from Textract were stellar. But results from preliminary tests using Document AI were not that great.

Challenges with authentication

Since the mantra of RunPage is to not send user data, like uploaded files to server-side for processing so that means the Textract API will need to be called from the browser itself. That means sharing server-side credentials. Right now the same AWS credential is used for all users, but if we leak it to the browser then enterprising users can capture those and use them elsewhere too.

RunPage solves it by getting a temporary credential before each run. The JS sandbox asks the server for a temporary short-lived temporary credential. The server gets them from AWS using AWS STS (Security Token Service) API and passes it on to the browser.

Challenges with handling PDF

RunPage uses synchronous API of Textract to analyse the images. However, that API does not support PDF files. For PDF the async version of the API is required. That version has loads of challenges.

First, it won’t accept PDF binary directly, instead it requires that we upload the PDF to S3 bucket and provide that location to the API. The API will then directly get it from the bucket. This itself is very challenging since now we have to integrate with S3 as well. Also now we need to store the PDF on a remote server, and it will stay there until we delete it from there. And, until the time it is deleted it can be accessed by other users since all share the same AWS account. A huge security issue.

The second issue is when Textract is done processing the PDF it will use AWS SNS service to push notification to RunPage server. So a deployment profile for SNS too is required, and a callback listener API on RunPage server. Also when then API is invoked it has to notify the client somehow, which will requires either Websocket or server polling. This also means that I need to store the response from AWS SNS for sometime in the DB. Too much plumbing just for an API, on top of that the additional cost of using S3 and SNS.

I thought of a long-polling trick which avoids some of these plumbing requirements on backend server side. The client makes a call to backend server for update from AWS SNS, and the backend API simply stores the Express response object in a hash-map. Since the response object has not been used to send any data yet, the request will show as pending on browser side. The timeout value can be set by client. The callback endpoint which will be triggered by AWS SNS can then lookup in that hash-map and pick the appropriate response object and directly send the reply to browser. However, this won’t work if we have more than one nodes running on backend sever side. The backend architecture uses a Nginx server Docker container which acts as reverse proxy for the NodeJs Docker container. Currently only one instance of the NodeJs container runs but the server is specifically stateless so that multiple instances of it can also be run behind load balancer.

Solution to the PDF handling challenges

My solution was to locally (that is in-browser) convert the PDF to images and then use the AWS Textract synchronous API for images.

To locally convert PDF to images I used Mozlilla’s PDF.js. The NPM package of that is called pdfjs-dist. It is a weird name, probably because the pdfjs name is already taken by some other developer.

Using that library also turned out to have its own mini challenge. The library requires that we provide it with a CanvasRenderingContext2D which we can get from <canvas> DOM. However, the sandboxed JS APIs run inside a Worker as described in my blog post – In Web Worker side we do not have DOM access. There is an experimental API called OffscreenCanvas, and browser support for that is not too great yet (in 2022). To handle such scenarios RunPage has some internal plumbing which we make use of here. The PDF File‘s ArrayBuffer is sent from the Worker thread to the main thread with instructions to decode the bytes and return the images of it page by page. The Worker then simply sends each page’s image to Textract for analysis. This has another good side-effect that we can pick and choose the exact pages we would want to analyse and only those pages will get sent. Another ace point for security.

A side note: While working on this I stumbled upon a browser bug which I have reported here - That took a lot of time figure out.

Overall it is cool and super useful feature. Head over to to experience yourself.

RunPage tech overview: Danfo.js integration

In my previous post – RunPage tech overview: JS Sandboxing, I discussed how I handled client-side sandboxing of script-block codes. Here I will describe how Danfo.js was integrated into RunPage API.

Why integrate Danfo.js?

Relational DB is quite popular because it allows us to query for variety of information by use of SQL statements. It is very versatile and powerful. However, that requires we host a relational DB at the server-side which further means now all data now needs to be imported into the DB and fetched back to client-side for processing. So there goes the speed and security of data features of RunPage.

Our modern browsers now do support Web SQL which allows to store all data right in the browser which solves the above two fundamental issues. But, we now then need to clear and rebuild the DB on every run. Remember every run of RunPage starts with a clean slate. Also we will need to deal provide an ORM to ensure easier working with Web SQL as SQL is inherently quite verbose and the table creation and data insertion process is pretty cumbersome. What we really need is SQL’s query power without its other pains. The answer to that is virtual tables or DataFrames.

DataFrame concept is made popular by Python’s Pandas. Danfo.js is meant to provide the power of Pandas in Javascript.

Using Proxy

ES6 have a neat little api called Proxy. I have used that extensibly while integrating Danfo.js into RunPage. If you do not know what Proxy is then in short it allows you to wrap any JS object where invoking any method, property, etc. on the wrapped object can be intercepted by your code and you have the ability to change the complete outcome. The way it is different from creating a simple wrapper is that instanceof operator will still work with your wrapper object as it would with the wrapped object, and you need not reimplement all methods etc. of the wrapped object to intercept them. A single method in your wrapper can intercept all method and property calls.

The reason I had to wrap Danfo.js’ DataFrame and Series is because of its plot api – If you notice the api there the plot is a method which takes input a DOM’s id where the graph is to be plotted. However, you do not have DOM access in script-block and I do not want you to have that access since RunPage needs to be able to decide where to render your graph. I use Proxy to to replace DataFrame and Seriesplot with my own version which eventually returns a JSON which the main thread code can interpret as instructions to render the plot.

Conceptually this was simple but quite challenging to actually implement because any kind of operation and series of method calls can eventually return a DataFrame or Series object. So RunPage wraps all objects returned by the wrapper object recursively including Arrays, Functions, etc.

How the main thread renders the graphs

The JSON object returned by the proxy plot is something like below.

            // Arguments passed to plot.pie()
      "dataframeOrSeriesJ": // DataFrame or Series data as JSON

Using these data a Danfo DataFrame or Series is recreated and the actual plot method is invoked. In the above example the invocation code will be something like dfObject.plot('generatedDomId').pie(...args).

The main thread runs a series of output formatters each of which is meant for to render a particular type of JSON. The DOM returned by the output formatter is then used another sub-routine to finally add it into appropriate location on the page. So, the plot output formatter does not know when its given DOM will be add to the page. Only when the DOM is added then the above code needs to be run to actually render the graph. For this another trick is used.

const id = uuidv4();
const {method, args, dataframeOrSeriesJ} =;

const div = document.createElement('div');
div.innerHTML = `<div class="outbox plot" id="${id}"></div>
<img data-id="plotLoader" src="${dummyImg}" style="height:1px;width:1px;" />`;
div.querySelector('[data-id="plotLoader"]').addEventListener('load', function plotter() {
    const dataframe = DataFrameOrSeriesJsonToDataFrameOrSeries(dataframeOrSeriesJ);
    const plotter = dataframe.plot(id);
    const plotM = plotter[method];
    plotM.apply(plotter, args);

return div;

Here we generate a div with a unique id which we later pass to the plot method. The neat trick to note here is the use of img tag. The src attribute contains path to an actual one pixel image transparent. When the image is loaded the browser invokes its load event handler which further invokes the actual plot function. Since the img tag is after the plot’s div hence we can be sure that by the time img‘s load is fired the div with the given id is already available.

Problems with Danfo.js

It claims to be Pandas’ equivalent in Javascript but in reality it provides fraction of the tools when compared with Pandas. It does not even provide a ‘not’ or ‘invert’ operator when querying data.

As of now I have filed three defects which are not even assigned to anyone or has any activity yet. The first of which was filed 20 days back. So it looks like after April 2022 the activity on this codebase has suddenly died out.

Looking at the kind of issues I have found the quality of this library is very poor. For example, it seems it is meant to process only numbers, strings and boolean data. If you store other JSON objects in DataFrame then it won’t complain but silently give you wrong and unexpected results. (ref) There lot more fundamental issues which makes it unreliable. In data processing the one thing which cannot be compromised on is reliability else what is the point of processing data if you cannot be sure if you can rely on its output or not! It even has a defect filed which claims that the current latest version 1.1.1’s package on NPM contains old code –; and this defect is more than month old and still zero activity on it.

So many issues and on top of that it has dependency on @tensorflow/tfjs which I do not need at all.

Given all these factors I am considering ripping out Danfo.js out of RunPage and replacing it with Data-Forge. However, I will first evaluate that extensibly so as not to commit the same mistake I did by integrating with Danfo.js.