I'm a software engineer focused on network systems and infrastructure software, with 14+ years of experience in networking. My work spans routing protocols, control-plane development, system programming, and packet-processing architecture.

I enjoy understanding how networking systems work internally—and implementing those ideas in code. My interests range from protocol state machines and routing information bases to packet forwarding, memory management, and high-performance user-space datapaths.

• 🧭 Professional focus: Network control plane, routing protocols, and systems software
• 🧱 Engineering foundation: C, Linux, data structures, concurrency, and system programming
• 🌐 Networking interests: BGP, EVPN, multicast, IPv4/IPv6, routing and switching
• ⚡ Performance interests: DPDK, packet processing, lockless data structures, and datapath design
• 🧪 Learning by building: I create implementations and labs to make complex systems tangible
• 🎓 Teaching: I create technical courses and practical learning resources for engineers

The tcpip_stack project is my long-running effort to explore and implement networking functionality through code. It brings together protocol implementation, control-plane concepts, packet processing, and systems engineering in a practical codebase.

The goal: learn networking deeply by implementing it—not only by configuring devices or reading protocol specifications.

• Protocol internals: turn specifications and design concepts into working implementations.
• Control plane meets data plane: explore how routes and protocol state influence packet forwarding.
• Systems-level engineering: work with memory, queues, concurrency, interfaces, and performance constraints.
• Practical learning: use the project as a foundation for experiments, demonstrations, and course material.

The broader vision is to develop a modular networking stack that can serve as a learning platform for:

• Implementing routing and switching functionality
• Understanding EVPN and BGP through code
• Experimenting with forwarding architectures
• Exploring DPDK-powered datapaths
• Building reproducible labs and educational content

➡️ Explore my repositories: github.com/sachinites

The following projects represent complementary explorations around the networking stack. Some are standalone experiments; others are integrations or components of the broader work.

Hands-on EVPN work covering route processing and forwarding implications.

• EVPN Route Type 2: MAC-only and MAC/IP advertisement concepts
• EVPN Route Type 3: Inclusive Multicast Ethernet Tag (IMET)
• MAC mobility and sequence-number behavior
• ARP suppression and MAC/IP reachability
• Route import/export and control-plane integration

Experiments with high-performance packet I/O and forwarding outside the conventional kernel networking path.

• DPDK poll-mode driver (PMD) interfaces
• RX/TX queues and packet-buffer lifecycle
• Mbufs, mempools, and rings
• Huge pages and memory considerations
• User-space forwarding architecture
• Exploring socket/TUN/TAP integration paths

A wrapper/integration experiment exposing GoBGP functionality through a C-facing API.

• C ABI around GoBGP gRPC functionality
• IPv4 unicast route operations
• EVPN Route Type 2 import/export experiments
• Multi-instance GoBGP testing and lab integration

Exploring the structures behind efficient route lookup and packet forwarding.

• Flat routing-table implementation
• Longest-prefix match
• Trie and multibit-trie approaches
• Memory layout and lookup trade-offs
• Unit testing and correctness validation

A packet-sniffer / packet-processing project exploring visibility and control over traffic.

• Interface-based packet capture
• Packet filtering and ACL concepts
• PCAP output
• Packet injection experiments
• CLI-driven workflows
• Recording packet metadata for analysis

Smaller implementations and learning projects around core Linux/C concepts:

• Threads and synchronization
• Atomic operations and compare-and-swap
• Lockless producer-consumer patterns
• Shared memory and memory mapping
• POSIX timers, semaphores, and file descriptors
• Socket programming and network utilities

My career has been centered on networking software engineering, evolving from protocol and network-system development toward broader systems and datapath engineering.

Networking foundations
        │
        ▼
Network protocol & systems development
        │
        ▼
Routing / switching / control-plane engineering
        │
        ▼
EVPN, multicast, BGP & network infrastructure
        │
        ▼
Staff-level engineering · cross-domain system integration
        │
        ▼
Expanding into high-performance datapaths & DPDK

• Cisco — Networking software engineering experience
• Calix — Network systems development, with focus on multicast and control-plane behavior

This is a high-level career summary, not a complete employment chronology. Add exact titles, dates, and earlier roles if you want a fully detailed timeline.

I believe strong networking engineers benefit from understanding both sides of a network system:

• Control plane: protocols, route computation, state machines, signaling, and convergence
• Data plane: packet parsing, forwarding, memory, queues, and performance

That is why I continue to explore DPDK and user-space packet processing alongside protocol development.

Teaching is an important part of my engineering journey. I create technical courses that help learners move beyond theory and understand systems through practical implementation.

Over time, I have built a catalog of technical courses on Udemy and learning resources through my own platform. My teaching focuses on practical explanations, implementation-oriented learning, and helping students understand what happens inside networking systems.

• Networking fundamentals and protocol behavior
• Routing and switching concepts
• System programming in C
• Building networking functionality through implementation
• Control-plane and data-plane architecture
• DPDK and high-performance packet processing
• Practical labs that connect theory with engineering

• 🎥 Udemy instructor: View my instructor profile
• 🌐 Learning platform: CSEPracticals
• 🧑‍🏫 Teaching philosophy: explain the concept, build it, test it, and understand its trade-offs

My engineering projects and teaching reinforce each other: building systems gives me practical material to teach, and teaching encourages me to make complex ideas clearer.

I value engineering approaches that emphasize:

1. Implementation over superficial familiarity — understand a system by building meaningful parts of it.
2. End-to-end thinking — connect protocols, APIs, data structures, and packet forwarding.
3. Correctness before optimization — establish behavior with tests, then measure and improve.
4. Readable engineering — design interfaces and code that others can understand and extend.
5. Continuous learning — keep expanding into adjacent domains without abandoning core expertise.

I'm interested in connecting with engineers and learners working on:

• Network operating systems and routing platforms
• BGP, EVPN, multicast, and control-plane development
• DPDK, high-performance networking, and packet-processing systems
• C/Linux systems programming
• Practical technical education