diff --git a/system_design.md b/system_design.md
new file mode 100644
index 0000000..0c2904e
--- /dev/null
+++ b/system_design.md
@@ -0,0 +1,467 @@
+# SIP System Design in Go with Consistent Hashing Load Balancing
+
+## Table of Contents
+
+1. [Introduction](#introduction)
+2. [Requirements](#requirements)
+3. [System Architecture Overview](#system-architecture-overview)
+4. [Components Description](#components-description)
+   - [1. SIP Signaling Server](#1-sip-signaling-server)
+   - [2. Media Gateway](#2-media-gateway)
+   - [3. Transcoding Service](#3-transcoding-service)
+   - [4. Conferencing Service](#4-conferencing-service)
+   - [5. DTMF Handler](#5-dtmf-handler)
+   - [6. Load Balancing with Consistent Hashing](#6-load-balancing-with-consistent-hashing)
+   - [7. Session Management (Stateless)](#7-session-management-stateless)
+   - [8. Monitoring and Logging](#8-monitoring-and-logging)
+5. [Data Flow Diagram](#data-flow-diagram)
+6. [Technology Stack](#technology-stack)
+7. [Handling Edge Cases and Challenges](#handling-edge-cases-and-challenges)
+8. [Scalability and High Availability](#scalability-and-high-availability)
+9. [Implementation Plan](#implementation-plan)
+10. [Testing Strategy](#testing-strategy)
+11. [Deployment Strategy](#deployment-strategy)
+12. [Future Expansion Planning](#future-expansion-planning)
+13. [Conclusion](#conclusion)
+14. [Next Steps](#next-steps)
+15. [Appendix](#appendix)
+
+---
+
+## Introduction
+
+This document outlines the design of a scalable SIP system in Go (Golang) that can accept and send SIP calls, handle media transmission using pion/WebRTC, support G.711 and Opus codecs with bidirectional transcoding, and provide conferencing features through audio multiplexing. The system employs consistent hashing for load balancing without the need for a dedicated proxy, ensuring high availability and statelessness.
+
+---
+
+## Requirements
+
+### Core Functionalities
+
+- **SIP Call Handling:** Accept and send SIP calls.
+- **Media Handling:** Use pion/WebRTC for media transmission.
+- **Codec Support:** Support G.711 and Opus codecs with bidirectional transcoding.
+- **Conferencing Features:** Implement audio multiplexing for conferencing.
+- **DTMF Support:** Handle out-of-band DTMF tones.
+- **Future Expansion:** Design with potential support for video codecs.
+
+### Non-Functional Requirements
+
+- **Scalability:** Support an average of 500 concurrent calls.
+- **High Availability:** Stateless architecture with failover mechanisms.
+- **Implementation Language:** Go (Golang).
+- **Tools Integration:**
+  - **Audio Multiplexer:** Use [audio-multiplexer-go](https://github.com/itzmanish/audio-multiplexer-go) for audio mixing and transcoding.
+  - **SIP Library:** Use [sipgox](https://github.com/emiago/sipgox) for SIP functionalities.
+
+---
+
+## System Architecture Overview
+
+![System Architecture Diagram](https://user-images.githubusercontent.com/your-username/your-repo/architecture-diagram.png)
+
+
+The system consists of the following key components:
+
+1. SIP Signaling Server
+2. Media Gateway
+3. Transcoding Service
+4. Conferencing Service
+5. DTMF Handler
+6. Load Balancing with Consistent Hashing
+7. Session Management (Stateless)
+8. Monitoring and Logging
+
+---
+
+## Components Description
+
+### 1. SIP Signaling Server
+
+**Responsibilities:**
+
+- Handle SIP signaling for call setup, maintenance, and teardown.
+- Parse and construct SIP messages using `sipgox`.
+- Manage SIP transactions and dialogs in a stateless manner.
+
+**Implementation Details:**
+
+- **SIP Library:** Utilize [sipgox](https://github.com/emiago/sipgox) for SIP functionalities.
+- **Stateless Design:** Store minimal state per transaction using tokens or IDs.
+- **Consistent Hashing:** Implement consistent hashing based on the `Call-ID` header to route SIP requests to the appropriate server instance.
+
+**Considerations:**
+
+- **NAT Traversal:** Use SIP headers and pion/WebRTC's NAT traversal capabilities.
+- **Future Video Support:** Design SIP handling to be flexible for future SDP attributes.
+
+### 2. Media Gateway
+
+**Responsibilities:**
+
+- Bridge media streams between SIP endpoints and pion/WebRTC.
+- Handle media stream setup using SDP negotiation.
+- Forward RTP packets between endpoints.
+
+**Implementation Details:**
+
+- **Media Handling:** Use [pion/WebRTC](https://github.com/pion/webrtc) for media transmission.
+- **Integration with sipgox:** Coordinate SDP negotiation and media setup.
+- **Codec Negotiation:** Manage codec capabilities during SDP negotiation.
+
+**Considerations:**
+
+- **Transcoding Integration:** Interface with the Transcoding Service when needed.
+- **Scalability:** Instances handle sessions independently due to stateless design.
+
+### 3. Transcoding Service
+
+**Responsibilities:**
+
+- Perform bidirectional transcoding between G.711 and Opus codecs.
+- Provide APIs for transcoding operations.
+
+**Implementation Details:**
+
+- **Audio Multiplexer:** Use [audio-multiplexer-go](https://github.com/itzmanish/audio-multiplexer-go) for transcoding.
+- **Concurrency:** Use Goroutines for efficient transcoding.
+- **Service Interface:** Expose transcoding functions internally.
+
+**Considerations:**
+
+- **Performance Optimization:** Profile transcoding paths to minimize latency.
+- **Resource Management:** Scale instances based on CPU usage.
+
+### 4. Conferencing Service
+
+**Responsibilities:**
+
+- Mix multiple audio streams for conferencing.
+- Manage conference sessions and participant lists.
+
+**Implementation Details:**
+
+- **Audio Mixing:** Utilize `audio-multiplexer-go` for audio mixing.
+- **Session Management:** Assign unique conference IDs and manage participant lists.
+
+**Considerations:**
+
+- **Scalability:** Distribute conferencing load across instances.
+- **Future Expansion:** Design to handle video streams in the future.
+
+### 5. DTMF Handler
+
+**Responsibilities:**
+
+- Detect and process out-of-band DTMF tones.
+- Provide DTMF events to applications or services.
+
+**Implementation Details:**
+
+- **RFC 2833 Compliance:** Handle DTMF events per RTP Payload for DTMF Digits.
+- **pion/WebRTC Integration:** Use pion's capabilities for DTMF handling.
+
+**Considerations:**
+
+- **Accuracy:** Ensure reliable detection for IVR systems.
+- **Performance:** Handle DTMF processing asynchronously.
+
+### 6. Load Balancing with Consistent Hashing
+
+**Responsibilities:**
+
+- Distribute SIP requests among server instances without a dedicated proxy.
+- Maintain session stickiness to ensure all messages in a SIP dialog reach the same instance.
+
+**Implementation Details:**
+
+- **Hash Function:** Use a consistent hash function (e.g., SHA-256) on the `Call-ID` header.
+- **Hash Ring:** Represent server instances on a virtual ring with multiple virtual nodes.
+- **Request Routing:** Each instance independently computes the hash and determines if it should handle the request.
+
+**Considerations:**
+
+- **Synchronization:** Ensure all instances use the same hashing algorithm and configurations.
+- **Failure Handling:** Implement mechanisms to update the hash ring upon server changes.
+
+### 7. Session Management (Stateless)
+
+**Responsibilities:**
+
+- Maintain minimal session information required for transaction processing.
+- Use tokens or IDs embedded in SIP messages for session correlation.
+
+**Implementation Details:**
+
+- **Stateless Tokens:** Embed session identifiers in SIP headers or use the `Call-ID`.
+- **Distributed Cache (Optional):** Use Redis if minimal shared state is necessary.
+
+**Considerations:**
+
+- **Failover:** Any instance can handle a session based on the hash function.
+- **Data Consistency:** Stateless design minimizes consistency issues.
+
+### 8. Monitoring and Logging
+
+**Responsibilities:**
+
+- Monitor system performance and health.
+- Collect logs for troubleshooting and analysis.
+
+**Implementation Details:**
+
+- **Monitoring Tools:** Use Prometheus and Grafana.
+- **Logging:** Implement structured logging.
+- **Alerts:** Set up alerting for critical events.
+
+**Considerations:**
+
+- **Scalability Monitoring:** Track resource usage for scaling decisions.
+- **Call Quality Metrics:** Monitor latency, jitter, and packet loss.
+
+---
+
+## Data Flow Diagram
+
+1. **Call Initiation:**
+
+   - A SIP endpoint sends an INVITE request.
+   - All SIP Signaling Server instances compute the hash of the `Call-ID`.
+   - The instance whose hash range includes the computed hash handles the request.
+
+2. **SIP Signaling:**
+
+   - The SIP Signaling Server processes the INVITE.
+   - Performs SDP negotiation for codec selection.
+
+3. **Media Setup:**
+
+   - The Media Gateway sets up RTP streams using pion/WebRTC.
+   - If transcoding is required, it interacts with the Transcoding Service.
+
+4. **Media Transmission:**
+
+   - RTP packets are forwarded between endpoints via pion/WebRTC.
+
+5. **Conferencing (If Applicable):**
+
+   - Media streams are sent to the Conferencing Service.
+   - The service mixes audio and sends it back to participants.
+
+6. **DTMF Handling:**
+
+   - Out-of-band DTMF tones are detected by the DTMF Handler.
+
+7. **Call Termination:**
+
+   - BYE requests are processed by the SIP Signaling Server.
+
+---
+
+## Technology Stack
+
+- **Programming Language:** Go (Golang)
+- **SIP Library:** [sipgox](https://github.com/emiago/sipgox)
+- **Media Handling:** [pion/WebRTC](https://github.com/pion/webrtc)
+- **Audio Multiplexing and Transcoding:** [audio-multiplexer-go](https://github.com/itzmanish/audio-multiplexer-go)
+- **Load Balancing:** Consistent Hashing implemented within the application
+- **Monitoring:** Prometheus and Grafana
+- **Containerization:** Docker
+- **Orchestration:** Kubernetes
+
+---
+
+## Handling Edge Cases and Challenges
+
+### 1. Codec Mismatch
+
+**Solution:** Implement SDP negotiation to select mutually supported codecs. Use the Transcoding Service when necessary.
+
+### 2. NAT Traversal Issues
+
+**Solution:** Use pion/WebRTC's built-in STUN/TURN/ICE capabilities.
+
+### 3. High Load Conditions
+
+**Solution:** Monitor system load and scale instances horizontally using Kubernetes auto-scaling.
+
+### 4. Failover and Redundancy
+
+**Solution:** Implement health checks and update the consistent hash ring when instances become unavailable.
+
+### 5. Latency and Call Quality
+
+**Solution:** Optimize media processing paths and adjust jitter buffers as needed.
+
+### 6. DTMF Detection Accuracy
+
+**Solution:** Ensure compliance with RFC 2833 and rely on out-of-band DTMF handling.
+
+---
+
+## Scalability and High Availability
+
+### Scalability
+
+- **Stateless Architecture:** Enables horizontal scaling.
+- **Consistent Hashing:** Distributes load evenly and minimizes impact during scaling.
+- **Microservices Approach:** Components can be scaled independently.
+
+### High Availability
+
+- **Multiple Instances:** Run multiple instances of each component.
+- **Distributed Deployment:** Deploy across different servers or data centers.
+- **Health Checks:** Regularly monitor and update the hash ring accordingly.
+- **Load Balancing:** Consistent hashing ensures minimal disruption during failures.
+
+---
+
+## Implementation Plan
+
+### Phase 1: Prototype Development
+
+- **SIP Signaling Server:**
+  - Implement basic SIP call handling using `sipgox`.
+  - Integrate consistent hashing for request routing.
+
+- **Media Gateway:**
+  - Set up media transmission with pion/WebRTC.
+  - Handle basic RTP forwarding without transcoding.
+
+### Phase 2: Feature Addition
+
+- **Transcoding Service:**
+  - Integrate `audio-multiplexer-go` for transcoding between G.711 and Opus.
+
+- **Conferencing Service:**
+  - Implement audio mixing using `audio-multiplexer-go`.
+
+- **DTMF Handler:**
+  - Add out-of-band DTMF detection and processing.
+
+### Phase 3: Scalability and Optimization
+
+- **Load Testing:**
+  - Simulate high call volumes to test load distribution.
+
+- **Performance Optimization:**
+  - Profile and optimize critical paths.
+
+- **Autoscaling:**
+  - Configure Kubernetes to scale services based on metrics.
+
+### Phase 4: High Availability
+
+- **Failure Handling:**
+  - Implement mechanisms to detect and handle instance failures.
+
+- **Consistent Hash Ring Management:**
+  - Develop protocols for updating the hash ring dynamically.
+
+### Phase 5: Monitoring and Maintenance
+
+- **Monitoring Setup:**
+  - Configure Prometheus and Grafana dashboards.
+
+- **Logging and Alerts:**
+  - Implement centralized logging and set up alerts.
+
+---
+
+## Testing Strategy
+
+- **Unit Testing:**
+  - Test individual components like SIP message parsing and transcoding functions.
+
+- **Integration Testing:**
+  - Test interactions between components such as SIP Signaling Server and Media Gateway.
+
+- **End-to-End Testing:**
+  - Simulate complete call flows including conferencing and DTMF handling.
+
+- **Load Testing:**
+  - Use tools like [SIPp](http://sipp.sourceforge.net/) to generate SIP traffic.
+
+- **Failure Testing:**
+  - Simulate server failures to test consistent hashing and failover mechanisms.
+
+---
+
+## Deployment Strategy
+
+- **Containerization:**
+  - Package services as Docker containers.
+
+- **Orchestration:**
+  - Use Kubernetes for deployment and scaling.
+
+- **CI/CD Pipeline:**
+  - Implement continuous integration and deployment using tools like Jenkins or GitLab CI/CD.
+
+- **Configuration Management:**
+  - Manage configurations using environment variables or config maps.
+
+---
+
+## Future Expansion Planning
+
+- **Video Support:**
+  - Ensure media handling components are flexible for video codecs and streams.
+
+- **Additional Codecs:**
+  - Design the Transcoding Service to add new codecs easily.
+
+- **Geographical Scaling:**
+  - Consider deploying regional clusters with DNS-based geolocation routing.
+
+---
+
+## Conclusion
+
+The proposed system design leverages Go's performance and the capabilities of `sipgox`, `pion/WebRTC`, and `audio-multiplexer-go` to build a scalable, stateless, and high-performing SIP system. Consistent hashing is used for load balancing, ensuring session stickiness without a dedicated proxy.
+
+---
+
+## Next Steps
+
+1. **Finalize Design:**
+   - Review the design with stakeholders and incorporate feedback.
+
+2. **Prototype Implementation:**
+   - Begin development of core components.
+
+3. **Testing and Validation:**
+   - Implement the testing strategy to validate functionalities.
+
+4. **Deployment:**
+   - Set up the infrastructure and deploy the system.
+
+5. **Monitoring and Optimization:**
+   - Continuously monitor the system and optimize as needed.
+
+---
+
+## Appendix
+
+### A. Glossary
+
+- **SIP (Session Initiation Protocol):** Protocol used for initiating, maintaining, and terminating real-time sessions.
+- **SDP (Session Description Protocol):** Format for describing streaming media initialization parameters.
+- **pion/WebRTC:** Go implementation of WebRTC for media streaming.
+- **Consistent Hashing:** A distributed hashing scheme that provides a hash table functionality in a decentralized manner.
+- **Goroutine:** Lightweight thread managed by the Go runtime.
+
+### B. References
+
+- [sipgox GitHub Repository](https://github.com/emiago/sipgox)
+- [pion/WebRTC GitHub Repository](https://github.com/pion/webrtc)
+- [audio-multiplexer-go GitHub Repository](https://github.com/itzmanish/audio-multiplexer-go)
+- [Consistent Hashing Algorithm](https://en.wikipedia.org/wiki/Consistent_hashing)
+- [RFC 3261 - SIP: Session Initiation Protocol](https://tools.ietf.org/html/rfc3261)
+- [RFC 2833 - RTP Payload for DTMF Digits](https://tools.ietf.org/html/rfc2833)
+
+---
+
+**Note:** This document is intended to serve as a comprehensive guide for the design and implementation of the SIP system. It should be used in conjunction with detailed technical specifications and development plans.
+
+# Thank You!