DROP TABLE
DROP DATABASE
TRUNCATE TABLE
DELETE without safe WHERE condition
deleteMany
removeMany
dropCollection
flushall
flushdb
dropping indexes
removing columns
renaming columns
destructive migrations
resetting migrations
clearing production cache blindly
removing production records

1. Take a backup
2. Verify environment is not production accidentally
3. Test migration on staging
4. Create rollback plan
5. Ask user for explicit confirmation

1. Data model design
2. Indexes
3. Query patterns
4. Pagination
5. N+1 query problems
6. Large payloads
7. Unbounded queries
8. Filtering and sorting
9. Joins / population / relations
10. Aggregations
11. Transactions
12. Connection pooling
13. Caching
14. Read/write separation
15. Migrations
16. Backups
17. Archiving strategy
18. Monitoring and slow query logs
19. Data retention
20. Scaling strategy

What fields are used in WHERE/filter?
What fields are used in SORT/orderBy?
What fields are used in JOIN/relation lookup?
What fields are used in GROUP BY/aggregation?
What fields must be unique?
What fields are used together often?

Creating random indexes on many fields without knowing query usage.

Creating indexes based on frequent filters, sorting, joins, uniqueness, and lookup patterns.

single-field index
compound/composite index
unique index
partial index
sparse index
TTL index
text/full-text index
geospatial index
covering index
foreign key index
case-insensitive index
hash index
GIN/GiST index in PostgreSQL

Fetch all users, then filter in JavaScript.

Filter in the database with proper indexes and limit.

limit
cursor or page
maximum limit
stable sort field
proper index

OFFSET 1000000 LIMIT 20

WHERE createdAt < lastSeenCreatedAt
ORDER BY createdAt DESC
LIMIT 20

SELECT *
Returning full documents when only a few fields are needed
Populating every relation
Including large JSON/blob fields unnecessarily

select only required fields
exclude sensitive fields
paginate nested data
load relations only when required

email
userId
organizationId
createdAt
updatedAt
status
slug
token hash fields
foreign reference fields
frequent search fields
compound filters
sort fields
TTL expiry fields

If query filters by userId and status, then sorts by createdAt:
index: { userId: 1, status: 1, createdAt: -1 }

lean queries for read-only responses
compound indexes for common filters
cursor-based pagination
projection/select fields
aggregation pipeline with $match early

primary keys
foreign keys
email/username
created_at
status
user_id
organization_id
slug
payment provider IDs
token hash fields
frequent WHERE fields
frequent ORDER BY fields

B-tree indexes for normal lookups
compound indexes for multi-column filters
unique indexes for uniqueness
partial indexes for filtered data
GIN indexes for JSONB/text search
trigram indexes for fuzzy search
BRIN indexes for very large time-series tables
expression indexes for lower(email)

If login uses lower(email), consider an index on lower(email).

For WHERE user_id = ? AND status = ? ORDER BY created_at DESC
consider index: (user_id, status, created_at)

cache
session store
queue backend
rate limiter
pub/sub
leaderboard
temporary tokens
distributed lock
real-time state

app:prod:user:123:profile
app:prod:rate-limit:login:ip:1.2.3.4
app:prod:session:abc

KEYS *
FLUSHALL
FLUSHDB

SCAN instead of KEYS
TTL for temporary data
small values
namespaced keys
safe cache invalidation

select only needed fields
use cursor pagination
add @@index and @@unique based on queries
use transactions for critical writes

lean read queries
projection
compound indexes
cursor pagination
safe schema indexes

Creating a new DB connection inside every request.

Use a shared database client or configured pool.

public read-heavy data
expensive computed data
user profile summaries
settings/configuration
rate limit counters
temporary auth/session state
frequent dashboard stats

highly sensitive data
rapidly changing financial data
unclear invalidation data
data requiring strict real-time consistency

reset database
drop table
drop column
truncate
delete all

EXPLAIN / EXPLAIN ANALYZE
slow query logs
query profiler
database metrics
application logs
APM tracing

Stage 1: Clean schema and correct indexes
Stage 2: Fix bad queries and add pagination
Stage 3: Add caching for read-heavy data
Stage 4: Add connection pooling and monitoring
Stage 5: Add read replicas for read-heavy workloads
Stage 6: Archive old data and partition huge tables
Stage 7: Split analytics/reporting workload
Stage 8: Shard only when truly needed

Is this production, staging, or local?
Do you have a recent backup?
Exactly which records should be deleted?
Should this be soft delete instead of permanent delete?
Do you want a dry-run query first?

First count the records that will be affected.
Then show sample affected records.
Then ask for confirmation.
Only then provide the delete command.

DELETE FROM users;

First run a SELECT/COUNT with the same WHERE condition.
Confirm the affected rows before deletion.

undefined

undefined