TCP

Opening thousands of TCP connections from a single server for data collection triggers firewall bot detection and IP blacklisting, blocking large-scale web scraping and data pipeline projects. This is a fundamental architectural limitation when trying to gather data from many sources simultaneously.

Per-packet load distribution forwarding schemes cause packets to arrive out of order, triggering TCP's fast retransmit algorithm and causing the sender to reduce window size, dramatically reducing throughput.

Traditional database setups (like RDS instances) are often not connected to the internet by default, making it extremely difficult to connect serverless compute platforms like Cloudflare Workers to them. This creates a significant operational burden for modern development workflows.

Middleboxes block non-TCP protocols (UDP, DCCP, SCTP) in corporate networks and censoring countries, forcing applications back to TCP despite TCP being unsuitable for many use cases.

16-bit TCP checksums are too weak to detect bit-flips; organizations implementing encryption see reduced crashes because encryption enforces stronger 128-256 bit checksums. This architectural weakness forces all-or-nothing security decisions.

TCP/IP achieves poor round-trip latency and cannot approach the raw capabilities of next-generation high-speed networks like Myrinet and ATM. TCP was designed for wide-area networks and is not optimized for local-area or high-bandwidth, high-latency connections.

TCP's reliability guarantees, connection overhead (3-way handshake), and flow control make it unsuitable for applications prioritizing speed over reliability, such as video calls, online games, and live streams, forcing developers to use UDP instead and lose reliability benefits.

TCP/IP architecture doesn't allow embedding application semantics into network packets, preventing application-level control over data transmission. This forces applications to build custom framing on top of TCP.

Multi-layer protocol stack organization (Sockets → TCP → IP → driver) requires costly layer transitions and data transformations at each boundary. Nearly one-quarter of small-packet processing time is spent on memory management (mbuf overhead and copying), and layer transitions consume significant processing overhead.

Tail-drop queuing combined with TCP slow-start causes all TCP streams to reduce window size simultaneously during congestion, leading to inefficient link utilization and bursty traffic patterns.

Protocols attempting to multiplex or pipeline concurrent commands over a single TCP connection encounter head-of-line blocking, where TCP's ordered delivery constraint prevents concurrent messages from being processed independently, forcing developers to re-implement flow control and framing.

Diagnosing TCP/IP performance issues requires checking multiple system layers (host memory/CPU, link errors, IP fragmentation, TCP retransmission, buffer sizes, MTU settings), with many interdependent configuration parameters and no straightforward diagnosis methodology, making performance troubleshooting tedious and time-consuming.

TCP uses per-packet checksums for end-to-end reliability despite modern network hardware already providing per-packet CRCs, creating redundant and expensive checksum computation that becomes a bottleneck in packet processing, especially on LAN where the extra reliability is unnecessary.

TCP's acknowledgement only confirms message receipt, not processing, forcing applications to implement their own redundant acknowledgement layers on top of TCP to ensure data has actually been processed by the receiving application.

TCP has a long history of unused or broken features (e.g., TCP urgent flag) that add complexity without functional benefit, creating legacy cruft that cannot be removed due to backward compatibility constraints.