## 4. High-Level Design

### Architecture Diagram Flow

1. **Client** sends a request.

2. **Load Balancer (LB)**: Distributes traffic across Web Servers.

3. **Web Server / API Gateway**: Handles validation, rate limiting, and authentication.

4. **Caching Layer (Redis)**: Stores mapping of `ShortURL -> LongURL`. Checks here first for redirection.

5. **Application Service**:

- **Shortening Service**: Generates unique ID.

- **Redirection Service**: Handles cache misses.

6. **Database**: Persistent storage for mappings and users.

7. **Async Workers (Kafka + Workers)**: Decouples analytics logging from the redirection path to ensure low latency.

### Architecture Diagram

```plantuml

@startuml

!theme plain

skinparam componentStyle rectangle

skinparam defaultFontSize 12

left to right direction

cloud "Clients\n(Browser / Mobile / API)" as clients

node "Edge Layer" {

[CDN / WAF\n(DDoS Protection)] as cdn

[Load Balancer\n(Round Robin / Least Conn)] as lb

}

node "Application Layer" {

[API Gateway\n(Auth, Rate Limit,\nValidation, Routing)] as gw

[Shortening Service] as shorten

[Redirection Service] as redirect

[ID Generation Service\n(Snowflake / Ticket Server)] as idgen

}

database "Cache Layer" {

[Redis Cluster\n(ShortURL → LongURL)\n+ Local Cache (Caffeine)] as redis

}

database "Data Layer" {

[URL Mapping\n(DynamoDB / Cassandra)\nHash-Based Sharding] as urldb

[User DB\n(PostgreSQL)] as userdb

}

queue "Event Stream" {

[Kafka\n(Click Events)] as kafka

}

node "Analytics Pipeline" {

[Analytics Workers\n(Batch Consumers)] as workers

[OLAP Store\n(ClickHouse / TimescaleDB)] as olap

}

clients --> cdn

cdn --> lb

lb --> gw

gw --> shorten

gw --> redirect

shorten --> idgen : Generate unique ID

shorten --> urldb : Write mapping

shorten --> redis : Warm cache

shorten --> userdb : Auth lookup

redirect --> redis : 1. Check cache

redirect --> urldb : 2. Cache miss

redirect --> kafka : 3. Push click event

kafka --> workers

workers --> olap

@enduml

```

### Sequence: Redirect Flow

```plantuml

@startuml

!theme plain

skinparam defaultFontSize 12

actor User

participant "Load Balancer" as LB

participant "API Gateway" as GW

participant "Redirection\nService" as RS

database "Redis" as Cache

database "URL DB" as DB

queue "Kafka" as MQ

participant "Analytics\nWorker" as AW

User -> LB : GET /{alias}

LB -> GW : Forward

GW -> RS : Route

RS -> Cache : GET alias

alt Cache Hit

Cache --> RS : long_url

else Cache Miss

RS -> DB : Query by hash

DB --> RS : long_url

RS -> Cache : SET alias → long_url

end

RS ->> MQ : Async push click event

RS --> User : 302 Redirect (Location: long_url)

MQ -> AW : Consume event

AW -> AW : Aggregate & store

@enduml

```

### Sequence: Create Short URL Flow

```plantuml

@startuml

!theme plain

skinparam defaultFontSize 12

actor User

participant "API Gateway" as GW

participant "Shortening\nService" as SS

participant "ID Generator\n(Snowflake)" as IDG

database "URL DB" as DB

database "Redis" as Cache

User -> GW : POST /api/v1/urls\n{long_url, custom_alias?, expire_at?}

GW -> GW : Validate, rate limit, auth

GW -> SS : Create request

alt Custom Alias provided

SS -> DB : Conditional write\n(check alias not exists)

alt Alias taken

DB --> SS : Conflict

SS --> User : 409 Conflict

end

else Auto-generate

SS -> IDG : Get unique ID

IDG --> SS : 64-bit ID

SS -> SS : Base62 encode → alias

SS -> DB : Write mapping

end

DB --> SS : OK

SS -> Cache : SET alias → long_url

SS --> User : 201 Created\n{short_url, hash}

@enduml

```

Submissions

Displaying Solutions with Scores Ranging from 1 to 10