shashidhar

Hi, I'm Shashidhar Biradar

Software Engineer specializing in distributed systems, backend infrastructure, and observability.

Currently an SDE Intern at project44, working on core data ingestion platforms and internal AI agents.

I care about how systems fail, how they scale, and what happens beneath the abstractions.

About Me

I am a Software Engineer focused on building and scaling resilient backend systems. I work primarily with distributed architectures, including Kafka-based data platforms and AI agent infrastructure.

My technical interests lie at the intersection of infrastructure and observability—specifically time-series databases, storage engines, and the foundational engineering that enables machine learning at scale. Outside of work, I spend time diving into system internals, contributing to open-source projects like Prometheus, and writing about technical trade-offs.

Experience

Software Engineering Intern — project44

December 2025 — Present

  • Engineering large-scale distributed systems for ingesting and processing real-time data via Kafka and RabbitMQ.
  • Developing high-performance data pipelines and dashboards using Python, PostgreSQL, and Snowflake.
  • Implemented observability with Datadog and managing AWS/GCP infrastructure via Terraform.
  • Building agentic AI architectures leveraging LangChain, RAG, and MCP with VectorDBs for scalable intelligent applications.

Backend Engineering Intern — Commutatus

  • Developed multiple Ruby gems to interface the DSL and raw customer data.
  • Developed production API endpoints and data queries using GraphQL.
  • Built reusable components and tooling to interface with domain-specific data.

Projects

I like building things that expose real constraints: concurrency, state, and scale. A few representative projects:

gammaDB

PostgreSQL Internals · Columnar Storage · C/C++

GitHub ↗

Analytical PostgreSQL extension for vectorized execution.

  • -Developed a native Postgres extension to bridge transactional and analytical workloads without relying on third-party OLAP engines.
  • -Implemented columnar storage formats and vectorized query execution to process row batches efficiently.
  • -Significantly improved data compression and read speeds for analytic queries directly within the database.

Learnings: Working inside Postgres internals highlighted the complexities of memory contexts, buffer management, and the trade-offs between row-oriented and column-oriented layouts for CPU cache efficiency.

queueCTL

Node.js · SQLite · Asynchronous Queues

GitHub ↗

CLI-based background job orchestration and persistent queue.

  • -Engineered a robust asynchronous task processing system backed by SQLite for state persistence.
  • -Designed a concurrent worker pool architecture with strict at-least-once delivery guarantees.
  • -Built comprehensive failure handling, including automatic retries, exponential backoff, and Dead Letter Queue (DLQ) routing for poisoned jobs.

Learnings: Handling concurrent SQLite writes and dealing with worker crashes taught me the nuances of database locking, transaction isolation, and preventing race conditions in state management.

deltax

API Gateway · Load Management · Distributed Systems

GitHub ↗

API gateway for isolating computationally intensive workloads.

  • -Designed a reverse-proxy routing layer to sit between client requests and backend compute nodes.
  • -Safely isolates expensive operations by managing load control, request delegation, and timeout constraints.
  • -Prevents main application servers from being overwhelmed by blocking tasks or heavy computational spikes.

Learnings: Abstracting heavy compute taught me about backpressure mechanisms, network I/O bottlenecks, and the critical importance of circuit breakers when upstream services degrade.

Hashd

Python · Celery · RabbitMQ

GitHub ↗

Distributed ETL pipeline for file integrity processing.

  • -Built an asynchronous data extraction and processing pipeline focused on high-throughput file integrity checks.
  • -Orchestrated distributed workers using Celery and managed message routing and state through RabbitMQ.
  • -Optimized pipeline bottlenecks to ensure reliable data ingestion under heavy concurrent loads.

Learnings: Scaling the pipeline exposed the realities of distributed message brokers—specifically around consumer prefetch limits, message acknowledgment strategies, and avoiding queue starvation.

Technical Skills

I focus on core engineering primitives and system behaviors, which allows me to adapt to new stacks and domains as needed.

Backend & Systems

Concurrency, memory management, background processing, and API design.

Go · Python · C/C++ · TypeScript

Distributed Infrastructure

Message brokering, event streaming, asynchronous queues, and handling backpressure.

Kafka · RabbitMQ · Celery

Data & Storage

Relational modeling, ACID transactions, in-memory caching, and time-series data storage.

PostgreSQL · MySQL · Redis · TSDBs

Observability & Cloud

System telemetry, metrics aggregation, log parsing, and infrastructure as code.

Prometheus · Datadog · Terraform · AWS/GCP

Notes and Explorations

A collection of design docs, incident postmortems, and deep dives into system internals. I use my notes to document architecture trade-offs, production debugging, and general learnings. Currently, I am actively studying:

  • Prometheus TSDB architecture and write-ahead logs.
  • Kafka partition internals and replication mechanics.
  • Storage engine layouts, checkpointing, and compaction.
  • AI agents reliability and better tool integration.
Read my technical notes ↗

Contact

I'm always open to discussing distributed systems, infrastructure, or open-source collaborations.

Reach out to me by email: shashidhxr@gmail.com