1. Can you describe the event loop phases in Node.js and explain how each phase processes asynchronous operations?
2. Can you explain the relationship between the poll phase and I/O operations in the event loop?
3. Could you clarify the difference between `setTimeout` and `setImmediate` in the context of the event loop?
4. How would you structure a NestJS application to handle high-concurrency payment processing while maintaining separation of concerns?
5. Can you describe how you would approach structuring a NestJS application, even if you're currently working with Express? What key components would you consider for handling high concurrency?
6. How would you ensure transaction management in this structure, especially for payment processing?
7. Could you elaborate on how you would handle errors in asynchronous flows within this structure?
8. What observability considerations would you implement to monitor the performance of your NestJS application?
9. What are the trade-offs between using worker threads versus child processes for CPU-bound tasks in a Node.js API server? Consider memory overhead, error handling, and development complexity.
10. Can you explain the shared memory capabilities when using worker threads?
11. How would you manage debugging complexity when using worker threads compared to child processes?
12. When designing a multi-tenant application using PostgreSQL, how would you structure your database to isolate tenant data while maintaining query efficiency?
13. Could you elaborate on the schema-based or row-level isolation approaches you might consider for this multi-tenant application?
14. What indexing strategies would you implement for tenant identifiers to ensure query efficiency?
15. Explain what a covering index is in PostgreSQL and how it differs from a regular index.
16. Can you explain what index-only scans are and how they relate to covering indexes in PostgreSQL?
17. What are the storage overhead considerations when using covering indexes?
18. How would you optimize a slow-running report query that joins three large tables in PostgreSQL?
19. Would you consider adding strategic partial indexes? If so, how would you determine which columns to index?
20. Would you consider using materialized views for recurring reports? If so, how would that benefit the performance?
21. How would you implement a soft-delete pattern in PostgreSQL while maintaining referential integrity and supporting efficient 'deleted' record recovery?
22. How would you ensure that filtered indexes are used for active records in this soft-delete pattern?
23. How would you ensure that filtered indexes are used for active records in this soft-delete pattern?
24. What implications would you consider regarding foreign key cascade when implementing a soft-delete pattern?
25. When would you recommend using MongoDB's aggregation framework versus application-side processing for data transformation?
26. What benefits do you see in terms of network payload reduction when using MongoDB's aggregation framework?
27. What computational complexity thresholds would you consider when deciding between aggregation and application-side processing?
28. When implementing event-driven architectures using SQS and SNS, how would you design for exactly-once processing semantics despite SQS's at-least-once delivery guarantee, and what edge cases require special handling?
29. What are the trade-offs between using Kafka versus RabbitMQ for implementing event-driven architecture in a regulated financial application? Consider compliance, delivery guarantees, and operational complexity.
