Why was PostgreSQL chosen for storing posts? How to determine which technology handles the load without sharding and replication (Postgres, Kafka, Redis, service in Go)?

PostgreSQL is chosen for storing posts due to its reliability, support for complex queries, transactions, and extensibility. It is well-suited for structured data with relationships and ensures consistency.

To understand which technology handles what load without sharding and replication, it is necessary to consider the features and type of load:

• PostgreSQL: suitable for OLTP with moderate load (thousands of requests per second on a powerful server). As the load increases, sharding or replication may be required.
• Kafka: designed for processing large streams of messages with high throughput and scalability. Handles millions of events per second well.
• Redis: in-memory storage, excellent for very fast data operations, caching, and queues. Can handle hundreds of thousands of operations per second on a single server.
• Go Service: a high-performance backend capable of processing a large number of requests with low latency, but scalability depends on architecture and infrastructure.

Example load estimate:

// Example of simple load on a Go service
for i := 0; i < 10000; i++ {
    go func() {
        // request processing
    }()
}

Ultimately, the choice depends on requirements for consistency, speed, data volume, and load characteristics. Without sharding and replication, PostgreSQL works well under loads up to a few thousand requests per second, Redis for very fast operations with small data, Kafka for event streams, and the Go service as an efficient logic handler.