Async progress tracking of compute-heavy node process via DB - node.js

Question

I have a compute-intensive, not-very quick, Node.js program. In order to provide some feedback about what it's doing, I'd like to update the status in a DB table to show what's going on.
A heavily stripped down example is shown.
Example PG declaration for the table:
sophia=> create table tracking(progress integer);
CREATE TABLE
sophia=> insert into tracking values(0);
INSERT 0 1
Node code:
const { Pool, Client, types } = require('pg')
// See https://node-postgres.com/api/pool
const db = new Pool({
host: process.env.DB_ENDPOINT,
user: process.env.DB_USERNAME,
password: process.env.DB_PASSWORD,
database: process.env.DB_NAME,
port: process.env.DB_PORT
})
for (let i = 0; i < 10; i++) {
// Do compute-intensive stuff
for (let j = 0; j < 1000000000; j++) {}
// Mark progress
console.log('i = ', i)
db.query(`update tracking set progress = ${i} where progress <= ${i} returning progress`).then(res => {
console.log('Progress', res.rows[0].progress)
})
}
The above is significantly simpler that my real code in the following ways:
It's just plain node - the real code runs in Lambda in AWS
This is just churning through busy-loops. The real code has serious business logic in which each step is different but will use certain elements of the previous operation.
The table is a trivial one-row, one-col example. The real one would track multiple elements based on different users, etc.
If these were really fire-and-forget, I'd expect them to update the DB and print the resulting return shortly after the operation was completed with some level of randomness and occasional delay. What I'm actually seeing is that they consistently do no updates at all until after the heavy computing is finished, which renders it useless.
16:17:16:~/ $ node heavy.js
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
Progress 0
Progress 1
Progress undefined
Progress 3
Progress undefined
Progress undefined
Progress 6
Progress undefined
Progress 8
Progress 9
This feels like a problem that must have been solved before. If there's a lib for doing this kind of operation, great. If there's a simple trick for getting the DB operations to trigger shortly after the result, that's fine. If there's some lambda-specific option for this, that'd also be great. Synchronously waiting for the DB at each step is obviously possible but seems really silly.