Yash B Joshi

Hyderabad, India

Yash B Joshi Backend Engineer

Workflow orchestration · Distributed systems · Python & Go

I build the parts of a system that have to be right, not just fast — workflow engines, async data layers, streaming pipelines, and the compilers and schedulers underneath them.

See the work GitHub ↗ LinkedIn ↗
Yash B Joshi, Backend Engineer

What I work on

The problems I reach for

Backend work where the failure modes are interesting — state that has to survive, schedules that have to be right, and systems that have to explain themselves.

01

Workflow orchestration & durable execution

Long-running processes that survive restarts, retries and partial failure. Temporal, compensation, and execution state you can still reason about a week later.

  • Temporal
  • Durable execution
  • Compensation
02

Compilers & DSLs

Turning a declarative definition into an executable plan — graph traversal, lowering, validation, normalisation. The interesting problems are all in the edge cases.

  • Graph traversal
  • IR design
  • Validation
03

Async Python at the data layer

SQLAlchemy 2.0, connection lifecycle, migration discipline. Async is easy to write and hard to get right once real load arrives.

  • SQLAlchemy 2.0
  • Alembic
  • PostgreSQL
04

Scheduling correctness

Recurrence rules, occurrence generation, timezone-aware scheduling — the class of problem where “it works” and “it's correct” are genuinely different claims.

  • Recurrence
  • Timezones
  • Calendars
05

Auth & access control

Asymmetric JWT, centralised verification, reusable middleware, and RBAC that still holds when the fifth service shows up.

  • JWT RS256
  • RBAC
  • Middleware
06

Observability of distributed work

Tracing an execution back to the intent that produced it, so a failure is diagnosable rather than a stack trace in a log nobody reads.

  • Tracing
  • Provenance
  • Failure analysis

Open source

Fixing the tools I depend on

zigflow/zigflow ↗ Durable workflows in YAML, powered by Temporal ✓ Merged
#568 — fix(utils): honour io.Writer contract in LogWriter.Write

An intermittent “short write” that killed script execution. A blank chunk returned n=0 with a nil error, and io.MultiWriter correctly treated that as a short write — so one stray newline aborted the whole command. Root-caused from a production symptom, reproduced with a regression test, fixed in one line.

  • Go
  • Temporal
  • io.Writer contract
  • Regression test

Listed in the project's AUTHORS file. More on the way — I'm upstreaming a set of engine fixes one at a time.

Selected work

Systems I've built and the calls I made

Described by the problem and the decision rather than the client — the interesting part was never the logo.

01

Enterprise automation platform

A visual workflow canvas, compiled to durable execution

Authors draw a workflow; it has to run reliably for hours or days. I work on the compiler that lowers that graph into an executable plan, and the contract between compiler output and a Temporal-based runtime. The part I find most interesting is provenance — mapping a live execution back to the node that produced it, so a failure points at a shape on the canvas instead of a stack trace.

  • Python
  • Temporal
  • DSL compiler
  • Kubernetes
02

Video management platform

Replacing my own streaming architecture

Started as an OpenCV proof of concept for multi-camera streaming, and scaled into a real backend. The design I had built first didn't hold on bandwidth or camera count, so I migrated the pipeline to HLS via FFmpeg. Later work moved it toward production: centralised asymmetric-JWT auth with reusable middleware, and an SSH-based deployment path with Docker image load/unload.

  • FFmpeg
  • HLS
  • ONVIF
  • JWT RS256
  • Docker
03

Education platform

Scheduling that has to be correct, not just plausible

A calendar module with a recurrence rule engine, occurrence generation and timezone-aware scheduling — where an off-by-one hour is a real bug for a real person. Built async-first on SQLAlchemy 2.0 with schema evolution handled properly through migrations, behind role-based access for several distinct user types.

  • FastAPI
  • Async SQLAlchemy
  • Alembic
  • GraphQL

Toolkit

What I build with

Everything below links out to the project itself. Hover to stop the drift — the same marks show up on the work cards, because they're the same tools.

Python TypeScript FastAPI DRF Temporal Celery PostgreSQL GraphQL Docker AWS Nginx OpenCV HLS
Go SQL Django SQLAlchemy 2.0 Zigflow Redis Alembic S3 Kubernetes Linux FFmpeg WebRTC

Get in touch

Happy to talk backend

Open to conversations about distributed systems, workflow orchestration, developer tooling, and open-source work.

LinkedIn ↗ GitHub ↗ Twitter ↗