nevzat aydın

When you order döner at midnight in Istanbul and it arrives in 23 minutes, that reliability didn't happen by accident. Behind the seamless consumer experience lies a profound engineering story - one shaped more by hard-won architectural decisions than by market hype. Nevzat Aydın didn't just build a company; he forced engineers to rethink how real-time distributed systems should behave when latency is measured in meals per minute, not milliseconds. I've spent years dissecting food-delivery platforms. And I still go back to the Yemeksepeti case whenever someone claims "we need Kubernetes to start. " The real innovation happened long before container orchestration was a blip on Turkey's radar.

Many Western engineers first encountered Turkish tech through the $589 million acquisition of Yemeksepeti by Delivery Hero in 2015. That exit, orchestrated by Nevzat Aydın alongside co-founders, validated not merely a business model but a set of deeply pragmatic engineering philosophies forged in one of the world's most demanding logistics environments. Istanbul's infamously broken address system, unpredictable traffic. And a massive offline-to-online transition forced the platform to solve problems that Silicon Valley took another five years to encounter at scale.

This isn't a puff piece about startup success. I want to walk you through the actual systems thinking - the databases, the idempotency keys, the agonizing over state machine transitions - that turned a 2001 monolithic PHP script into a platform handling over 3 million monthly orders before the acquisition. We'll pull back the curtain on the architecture that Nevzat Aydın's teams evolved, capturing lessons still relevant in 2025 for any engineer building a real-time marketplace that can't afford to lose a single order.

The Unforgiving Street: Why Istanbul Shaped a Different Tech Stack

To understand the technology behind Yemeksepeti, you first need to appreciate the environment. Istanbul's address system historically lacked standardized postal codes for buildings; many residential blocks are identified by colloquial names and relative landmarks ("behind the old Akbank ATM"). Western-style geocoding APIs would confidently return coordinates that placed a customer three hills away from their actual kitchen door. Nevzat Aydın's early realization was that the platform couldn't rely on third-party mapping alone if delivery promises were to be upheld.

Instead, the engineering team invested heavily in a proprietary geospatial layer that blended municipal GIS data, crowd-sourced corrections. And a reverse-geocoding logic tuned to the city's naming conventions. This wasn't a "nice to have" - it was the primary data backbone. We've discussed similar challenges in our guide to handling dirty spatial data. The team used PostgreSQL with the PostGIS extension (PostGIS documentation) long before it became standard in mobility startups, running spatial joins to map restaurant delivery polygons against these rough coordinates. The insight? If you can't find the door, your latency is infinite, regardless of how optimized your matching algorithm is.

Nevzat Aydın's leadership pushed the team to treat the address normalization pipeline as a first-class service, not a data cleanup script. They built an admin console where operations staff could manually correct coordinates tied to phone numbers, which then fed back into the geo-model. This human-in-the-loop system ran for over a decade and became the secret sauce that allowed delivery ETAs to remain credible even when Google Maps estimated a walking-only last mile.

From Monolithic PHP to a Modular Mess: The Pre-Kubernetes Era

Yemeksepeti launched in 2001 on what Nevzat Aydın has described in interviews as a classic LAMP stack. By the time it reached serious scale around 2010, the monolith was groaning under the weight of nested database queries that joined restaurants - menu items, orders and driver locations all in a single request context. The engineering team didn't have the luxury of a greenfield rewrite; they had to keep Friday night lahmacun orders flowing while gradually decoupling the system.

Their approach anticipated the strangler fig pattern. They first extracted a dedicated service for restaurant inventory. Because menu stale-reads were causing thousands of erroneous "item unavailable" cancellations. They moved that service to its own Java process (a departure from the core PHP) and set up a synchronization protocol using MySQL binlog replication to a denormalized read-model. This was pre-CDC tools like Debezium, so they built custom consumers. Nevzat Aydın's insistence on backward compatibility meant the old monolith continued to query the same endpoints via HTTP. But the new service eventually became the source of truth for all menu reads.

I mention this because I've consulted for startups that try to leap straight to microservices before understanding their data access patterns. Yemeksepeti's step-by-step approach, under Nevzat Aydın's pragmatic direction, minimized corporate risk. By 2013, they had a handful of Java services communicating over REST, with a homegrown service discovery mechanism based on Zookeeper. It wasn't pretty, but it survived Ramazan traffic spikes that would have melted a shared database connection pool.

Real-Time Dispatch and the Geospatial Event Bus

The core of any food delivery platform is the moment an order is placed and the system must decide which driver to assign. Early Yemeksepeti used simple queue-based assignment: first-in, first-out. But as restaurant prep times varied wildly and drivers clustered in busy neighborhoods, they needed a true geospatial dispatch engine. The team, guided by Nevzat Aydın's operational sensibility, chose to build an event-driven architecture around Apache Kafka (Kafka documentation), a choice that was quite forward-looking for a Turkish tech company in 2012-2013.

Driver locations were published every few seconds to a Kafka topic, ingested by a stream processor that maintained a Redis geohash index of available couriers. When a new order event arrived, the matcher service queried Redis's GEORADIUS command to find drivers within a configurable radius of the restaurant, filtered by vehicle type and current load. This avoided hammering the main database. The entire matching cycle ran under 200ms. But the real engineering challenge was idempotency: if a driver's phone lost signal and reconnected, duplicate location events could corrupt the state. The team implemented a custom deduplication guard using order IDs and driver session tokens in the stream processor, a technique documented well in Kafka Idempotent Producers best practices.

Nevzat Aydın prioritized driver acceptance rate and customer satisfaction over absolute throughput. So the dispatch service incorporated a "offer-first" model: the system would select up to three candidates and send a push notification (via FCM and later a proprietary WebSocket channel) with a 30-second timeout. The first to accept got the job. This behavioral design, rather than a purely algorithmic assignment, reduced no-shows by 18% according to internal metrics I recall from a EuroPython talk by one of their engineers. Technology served human incentives, not the other way around.

The Idempotency Key Pattern: Protecting Order State Machines

If there's one technical concept I associate with a Nevzat Aydın-led engineering org, it's a borderline obsession with idempotency. Food ordering is a financial transaction; duplicate charges erode trust instantly. The Yemeksepeti architecture adopted an order state machine with strictly defined transitions: Created → Confirmed → Preparing → ReadyForPickup → PickedUp → Delivered. And each transition could only be triggered once, enforced by database-level unique constraints on a combination of order ID and event type.

They generated a client-side UUID for every order placement request. That UUID served as the idempotency key, stored in a separate ledger table with a TTL of 48 hours. The API gateway would check the ledger before forwarding to the order service. If the UUID already existed, it returned the previously stored response. This is identical to Stripe's Idempotency-Key header behavior (Stripe idempotent requests documentation). But Yemeksepeti built it in-house around 2010, when many payment gateways didn't reliably support it in the Turkish market.

This might sound trivial to developers who have grown up with serverless frameworks that handle idempotency out of the box. But remember, this was running on bare-metal servers in a data center in Ankara, with developers manually patching the Linux kernel for network tuning. Nevzat Aydın's emphasis on financial correctness forced the team to extend this pattern to driver payouts, refunds and even the loyalty coupon system - each subsystem had its own idempotent ledger, ensuring that at month-end, the books tied out without painful manual audit.

Data Consistency Without Distributed Transactions: Practical Sagas

When orders involved multiple restaurants (dessert from one place, main dish from another), Yemeksepeti faced a distributed transaction problem. They couldn't afford long-running 2PC locks that would block a courier from picking up the first meal. Under Nevzat Aydın's guidance, the team implemented a bespoke saga orchestrator - long before the term "microservices saga" entered mainstream vernacular.

The orchestrator service would split a multi-restaurant order into sub-orders, each with its own state machine. It issued commands like ReserveInventory, and upon receiving success events, proceeded to the next step. If a restaurant rejected the sub-order because of stock, the orchestrator would cancel the other sub-orders by emitting compensating commands. The messaging backbone was the same Kafka cluster, ensuring at-least-once delivery. The daunting part was handling exactly-once semantics across boundaries. The engineers built a "transactional outbox" pattern: any database update that changed order state also wrote an event record to a local outbox table in the same MySQL transaction. A separate polling process sent those events to Kafka, achieving atomicity without distributed transactions.

This design, inspired by the work of Pat Helland and later formalized in event-driven microservices literature, was a direct response to the problems Nevzat Aydın observed on the operations floor: incomplete orders where the driver arrived at one restaurant but the other order was missing. The saga approach reduced those incidents by 70% and allowed the platform to scale the multi-vendor feature without an exponential complexity curve.

Mobile Engineering in a Fragmented Device Market

In Turkey during the 2010s, the Android market was dominated by low-end Samsung devices with limited memory and unreliable network conditions. Yemeksepeti's consumer app had to function gracefully on a 512 MB RAM device with 3G connectivity that frequently dropped to EDGE. The mobile engineering team. Which Nevzat Aydın championed as a separate division early on, adopted an "offline-first" strategy using local SQLite databases on the device.

They cached restaurant listings, menu images with aggressive compression, and the most recent 50 order histories. When a user placed an order in a spotty network, the app would queue the operation and send it when connectivity returned, using the idempotency-key approach described earlier to prevent duplicates. The Android client was written in Java with a custom content sync adapter. While the iOS team used Core Data with incremental sync via REST endpoints that supported If-Modified-Since headers. This reduced payload sizes dramatically.

Nevzat Aydın's empathy for the end user - many of whom were first-time smartphone owners - meant that technical choices were driven by real-world testing, not just emulators. Engineers regularly ate meals while tethered to a throttled connection, experiencing the same frustration that would lead to a 1-star rating. The result was a mobile architecture that prioritized resilience over flashy animations, a lesson worth revisiting in an era of bloated JavaScript bundles.

Observability When the Kitchen Is on Fire: SRE Before the Acronym

Food delivery has a brutal peak-hour pattern: between 18:30 and 20:00, the system is pushed to its limits. Nevzat Aydın insisted that the platform never show an "error occurred" message to a hungry customer. To achieve that, the ops team needed visibility into every layer, from the nginx reverse proxies to the driver smartphone app's heartbeat.

They built a homegrown monitoring stack using Ganglia for infrastructure metrics, custom JMX exporters for Java services. And a centralized logging pipeline based on syslog-ng feeding into an Elasticsearch cluster. Dashboards showed live order throughput, restaurant confirmation latency, and driver location stale-times. When the queue depth on the dispatch Kafka topic exceeded a threshold, an alert would fire not just to an ops bot but to a role called "order firefighter," who had the authority to temporarily disable discounts or shift capacity manually.

In one particularly memorable incident, a memory leak in the Java menu service caused JVM garbage collection pauses at the exact moment of evening rush. The team, following runbooks that Nevzat Aydın had insisted be written for every service, drained traffic from that node while live orders were in flight - all without a single lost order. This discipline of writing operational playbooks for every critical service, even before Kubernetes readiness probes became common, was a hallmark of the engineering culture Aydın fostered.

Nevzat Aydın's Leadership in Tech Supplier Negotiations

An often overlooked aspect of building a tech giant is the procurement of infrastructure. In early 2000s, Nevzat Aydın had to convince Turkish telcos to provide stable internet connectivity to restaurants, many of which had never before relied on a constant data connection. The Yemeksepeti team designed a custom Android-based POS terminal (before they had a native tablet app) that connected via GPRS modems and they negotiated bespoke APN configurations with Turkcell to ensure low-cost data.

Later, when cloud adoption became feasible, Nevzat Aydın oversaw a politically sensitive migration from a state-owned data center provider to a private cloud infrastructure running OpenStack. This