Python

Can you tell more about VACUUM? What types of VACUUM are there?

Provide an example of a situation where technically JOIN can be used and it will work, but for some reasons it would be suboptimal, and it is better to use prefetch_related (two queries).

Where should secrets such as tokens, passwords, and other sensitive data be stored?

Have you had experience working with Django?

Regarding caching: tell me, what are potential problems when using cache, pitfalls that can cause serious issues?

What is the difference between [x for x in y] and (x for x in y)?

How does the refresh token ensure security? What should be done if the refresh token is stolen?

Tell about developing with neural networks: if you need to fully implement a large feature through a tool like Cursor — how would you do it step by step? What stages would you divide it into, and what nuances in prompts would you specify?

How to find a flaky (unstable) unit test? What could be the reasons?

Tell about your experience with CI/CD pipelines, linting, testing, Docker images.

There is a large important report that takes a long time to generate. We cache it but do not know how often to update it (at different periods depending on data changes). How is cache invalidation handled in this case, and how should it be done?

Do you know the differences in scaling models between Uvicorn and Gunicorn?

When is a generator completely unusable, and when is it necessary to use a list? For example, if you need to iterate multiple times, is a generator suitable?

[x for x in y] versus (x for x in y)

Do you use AI tools in daily development?

What happens when a nested transaction (atomic inside atomic) is called in Django?

Have you mainly worked with FastAPI or Django? Can you explain select_related and prefetch_related — what are they and why?

For what tasks is it better to choose a message broker?

Let's discuss the internal data structures in Python, specifically their algorithmic complexity. Let's start with lists — please tell me the complexity of the main operations on a list.

Regarding relational databases in general (not specifically about PostgreSQL): if the database cannot handle the volume of data, and read/write operations are slow — explain step-by-step, from simple to complex, how to optimize this situation.