availableOpen to backend rolesOpen to backend & product engineering roles Open-source contributor

Backend systems
that feel effortless

Node.js · TypeScript · NestJS · PostgreSQL · Redis · Socket.io

Most of my time goes into building the stuff users never see but always feel — auth flows, data models, APIs, caching layers, and the glue that keeps real-time features from falling apart. Lately I've been deep in a CRM/ERP codebase where one wrong abstraction breaks three modules, so I focus heavily on domain modeling, event-driven patterns, and writing code that the next person can actually follow.

Get in touch GitHub

role: Backend Engineer
base: Egypt · --:-- Cairo
focus: APIs · Realtime · Auth · AI
built: 4 projects · 3 live
open source: WordyMe · sigstop

PATCH/api/documents/:id200 OK28ms

span0ms28msdur

auth.getSessionbetterAuth.getSession4ms
zod.parsezod.parse(UpdateDocument)1ms
db.documents.updatedb.documents.update9ms
db.revisions.insertdb.revisions.insert6ms
io.to(space).emitio.to(space).emit4 peers3ms

↳ session → validate → write doc + revision → broadcast to peers in the space

trace c21d0e8a77f1 · sample, not measuredauthcachedbaieventrealtimecompute

01/selected work

What I've built.

Four projects, each with a different shape. On the web ones the backend work is mine; sigstop I built end to end.

01/04~/projects/wordymeossopen sourcelive

WordyMe OSS

Open-source educational platform

Self-hostable education workspace with hierarchical documents, real-time sync, and a rich editor.

I jumped in to tackle the most complex backend features—specifically figuring out how to efficiently store nested document hierarchies and getting real-time collaboration to stay perfectly in sync.

Live site Source

Monorepo setup: Turborepo splits the SDK, types, UI, and editor into their own packages — so nothing bleeds where it shouldn't.
Live collaboration: Socket.io handles the syncing so two people can edit the same doc without stepping on each other.
Nested documents: Spaces, notes inside notes, favorites, version history — basically the hierarchy you'd expect from a real workspace.
Built to self-host: Fully self-hostable so teams can deploy it on their own infrastructure and keep complete control over their internal documents.

sample tracePATCH/api/documents/:id200 OK28ms

span0ms28msdur

auth.getSessionbetterAuth.getSession4ms
zod.parsezod.parse(UpdateDocument)1ms
db.documents.updatedb.documents.update9ms
db.revisions.insertdb.revisions.insert6ms
io.to(space).emitio.to(space).emit4 peers3ms

illustrative · mirrors how the request is wired, not measured

Express.jsBetter AuthDrizzle ORMlibSQLSocket.ioZodOpenAPITurborepo

02/04~/projects/reactsuite · currentwipin development

ReactSuite

Next-gen ERP/CRM platform

An ERP/CRM platform I'm building for teams that outgrow spreadsheets — focused on clean domain models, fully typed APIs, and live dashboards.

I'm focusing on building an architecture that won't turn into a mess later. That means organizing code by domain, keeping modules decoupled, and enforcing strict type safety.

Visit site

DDD structure: Structuring the logic so each module owns its own domain. This helps keep complex business rules organized and readable.
Event bus: Modules talk through events, not direct imports. So when Orders changes, Invoices reacts without either knowing the other's internals.
Typed APIs (oRPC): Using oRPC to share types between the frontend and backend, catching schema changes at build time instead of in production.
Live dashboards: SSE pushes updates to the UI as things happen — no polling, no stale data sitting on someone's screen.

sample tracePOST/rpc/orders.create200 OK41ms

span0ms41msdur

auth.sessionbetterAuth.session3ms
orpc.validateorpc.validate(input)1ms
orders.create (tx)orders.create (tx)18ms
bus.emitbus.emit(OrderCreated)2 subs1ms
invoicesinvoices.onOrderCreated12ms
inventoryinventory.onOrderCreated8ms
sse.pushsse.push(dashboard)2ms

illustrative · mirrors how the request is wired, not measured

NestJSTypeScriptoRPCDrizzle ORMPostgreSQLBetter AuthAmazon S3ZodSSESentryDocker

03/04~/projects/sigstopossopen sourcelive

sigstop

Open-source macOS menu bar app

Break reminders for developers that know what you're doing, and when not to interrupt. Free, open source, and private by design.

I built it end to end in Swift 6: a session model that counts real work instead of wall-clock time, a decision engine that waits for a defensible moment, and an activity classifier that never claims more than its signals support.

Live site Source

Counts real work: Continuous active work, not elapsed time. Short reading pauses still count; long idle gaps, sleep and time away don't.
Knows when to wait: Holds a break while your mic or camera is live or you're in a meeting, then escalates in four rungs named after Unix signals.
Private by design: Zero permissions required. It reads which app is in front, never what's in it, and nothing about you leaves your Mac.
Verified updates, tested core: Layered SwiftPM targets with one dependency, Sparkle, which checks every update against an EdDSA key. 587 tests run in CI.

break ladderfour prompts, each a little firmer

L1
SIGTSTP
noticed you, no pressure
L2
SIGINT
hm, still going?
L3
SIGTERM
this is your warning, said flat
L4
SIGSTOP
a bluff you're in on

SwiftSwiftUIAppKitSwiftPMSparkleGitHub Actions

04/04~/projects/turjumanlive

Turjuman

AI-powered translation platform

Translate text or speak into it — powered by Gemini and Deepgram, with saved history and a free/premium tier system.

I built out the backend pipeline, wiring up the external AI services and setting up caching and usage limits to keep everything fast and predictable.

Source

User accounts: JWT-based auth — users can save translations, search their history, and bookmark favorites.
Usage limits: Free users get a cap, premium users get priority. The logic tracks it all per-account.
Voice input: You talk, Deepgram transcribes it, Gemini translates it. The whole chain runs in one request.
Cached reads: Translations sit in MongoDB, but hot data goes through Redis so repeated lookups are instant.

sample tracePOST/api/v1/translate/voice200 OK731ms

span0ms731msdur

auth.verifyJwtauth.verifyJwt3ms
usage.checkQuotausage.checkQuota2ms
redis.getredis.get(translation)miss1ms
deepgram.transcribedeepgram.transcribe268ms
gemini.translategemini.translate431ms
redis.setredis.set(translation)1ms
mongo.historymongo.history.insert12ms
usage.incrementusage.increment2ms

illustrative · mirrors how the request is wired, not measured

Node.jsExpress.jsMongoDBMongooseJWTRedisDeepgramGoogle GeminiVercel

02/how I work

Habits I bring to every codebase.

Not frameworks or methodologies — just the things I've learned to do by default because skipping them always costs more later.

defaults.tsts

1export const defaults = {2  contractFirst: [3    "route design", "zod validation", "error contracts",4  ],5  dataHasAnOwner: [6    "aggregates", "bounded contexts", "targeted caching",7  ],8  secureByDefault: [9    "auth checks", "input sanitization", "rate limits",10  ],11  writeForTheNextDev: [12    "clear naming", "good logs", "obvious boundaries",13  ],14} as const;

01Architecture
I start with the API contract
I prefer to define the routes, validation, response shapes, and error cases before writing feature code. It helps save everyone time later — especially the frontend devs consuming the API.
#route-design#zod-validation#error-contracts
02Reliability
Data belongs somewhere specific
I try to ensure every piece of data has a clear owner. I rely on domain-driven principles to keep the logic organized, adding indexing and caching only where queries actually need it.
#aggregates#bounded-contexts#targeted-caching
03Trust
Security ships with the feature
Permission checks, input sanitization, and rate limits shouldn't be a follow-up ticket. I make sure they are baked in from the start to ensure the application is secure by default.
#auth-checks#input-sanitization#rate-limits
04Maintainability
I think about who's next
I write code assuming someone else will maintain it. I prioritize clear boundaries, good logs, and obvious naming so the next engineer doesn't have to reverse-engineer my work.
#clear-naming#good-logs#obvious-boundaries

03/technical stack

What I use, and where.

36 tools, grouped by where they sit in the stack.

API & runtime

Runtimes, frameworks, typed contracts, validation.

Node.js
TypeScript
Express.js
NestJS
Hono
oRPC
Zod
OpenAPI

Auth

Sessions, JWTs, role-aware endpoints.

Better Auth
JWT

Data & cache

Relational and document databases, ORMs, caching.

PostgreSQL
MongoDB
Mongoose
Drizzle ORM
libSQL
SQLite
Supabase
Redis

Realtime

Socket rooms and server-sent events.

Socket.io
SSE

Infra & delivery

Monorepos, containers, object storage, logs, error tracking, deploys.

Turborepo
Docker
Amazon S3
Vercel
Sentry
Pino
Dokploy
Coolify

AI

LLM and speech-to-text pipelines behind caching and limits.

Google Gemini
Deepgram

Client & native

React to ship a web UI and work well with frontend teams; Swift for native macOS apps.

Next.js
React

Tailwind CSS
shadcn/ui

TanStack Query
Swift

04/contact

open to backend rolesopen to backend & product engineering roles

Let's build a backend that makes the product feel instant.

Reach out for backend roles, API-heavy products, AI integrations, or systems that need reliable auth, data, and real-time workflows.

mohamedelshesheny62@gmail.com

Send an email

contact.jsonjson

1{2  "linkedin": "mohamed-elshesheiny" on LinkedIn (opens in new tab),3  "github": "Mohamed-Elshesheny" on GitHub (opens in new tab),4  "location": "Egypt",5  "local_time": "--:-- Cairo",6  "open_to": ["backend", "product"]7}

Backend systems that feel effortless

What I've built.

WordyMe OSS

ReactSuite

sigstop

Turjuman

Habits I bring to every codebase.

I start with the API contract

Data belongs somewhere specific

Security ships with the feature

I think about who's next

What I use, and where.

API & runtime

Auth

Data & cache

Realtime

Infra & delivery

AI

Client & native

Let's build a backend that makes the product feel instant.

Backend systems
that feel effortless