arunnanda

As part of an embeddable video player I'm starting to build, I need to have some way of keeping track of viewer behavior.

The easy way is to integrate something like Mux (YC Winter 2016). The even easier way is to just use an existing player like video js. But I want to start off by building my own solution.

I have the basic player working (still some race conditions to be resolved), so now I am starting to look at tracking viewing behavior. I need to know things like timestamp till which a viewer has watched the video, at what timestamps they paused/played/forwarded it, when they wanted to seek to an earlier time and rewatch a part of it, etc. etc.

Say I start a timer when the viewer presses play. Then for each (milli)second I can check the timestamp of the video - this will let me track if some parts of the video were replayed or fast forwarded. Whenever the viewer presses play/pause/forward, I record the event. I send this info to the server every 1 or 2 or 5 seconds and do the analytics.

Since I haven't done this sort of thing before, I would love to have some inputs on if this ^ is the right approach.

Does it make sense to treat this data as a timeseries data? If not (even if it is), what else is a good way to organize this data?

I assume something like Cassandra (which I haven't used much) is much better suited for this than Postgres (which I am comfortable with). Is this right?

Hypothetically, consider a social photo platform - each pic gets its own url, this page contains the image, text about the image, buttons for the user to click, related pics, and some user-specific elements (maybe notifications, etc.).

There are different ways of going about the frontend. In each case, elements specific to the logged-in-user and the related images get fetched via api calls and are rendered client side.

For rendering the rest of the page -

1. Everything is rendered client side - one can use a single page application to handle the routing. The page structure stays the same, and new image uri's and the associated content are fetched via api calls.

SEO is a priority, so pure client side rendering is suboptimal.

2. Server side rendering for each page with NextJS or even Express is another option.

3. Another way is to do a static export in something like NextJS - which will generate separate html files for each image.

4. Now my thought is to skip all of that and go old school with sed/awk. We'll have a template file with all the styling elements and placeholders for the image uri and its description, etc. Then a script iterates through a list of values (queried from a database) specific to each image (img source URIs, description text, etc.) and uses sed to replace the placeholders in the template file and output a separate html file.

Each file has the same javascript to load the user-specific components.

Every time someone adds a new image, the script runs with the uri of the image and the description, etc. as the variables passed to it, and adds a new html file in a flat file structure.

These "variables" are stored in a database. So whenever we change the "design" of the page, we repeat the same process again - regenerate each html file.

The flat file structure will run into limitations, which is solvable with a directory structure. Nginx remains performant with large numbers of files.

Right now, we use NextJS with a mix of server side rendering and static pages, so it is all good. But I have been wondering about achieving something similar with more rudimentary (and performant) tools.

There's not too much additional work involved - templatizing the html file is straightforward, and this won't be difficult to script.

What's good and bad about this?

I understand the meaning and significance of testing the key assumptions,

In order for the idea to be viable, the key assumptions must hold true. These key assumptions need to be validated in initial user research (in my own words).

But I am somewhat at a loss in listing out what the key assumptions actually are. For me it is just the solution to a problem that annoys me.

Any tips or links to useful resources will be much appreciated.