Technical Expertise
This is not just a list of tools. These are the areas where I have used the stack to ship product workflows, internal platforms, and production systems.
Production experience building workflow-heavy React and TypeScript interfaces for commerce, catalog, vendor, and internal operations teams.
Hands-on backend ownership across Rails APIs, REST and GraphQL contracts, Sidekiq jobs, service behavior, validation, and debugging.
Strongest in Ruby, JavaScript, TypeScript, and SQL, with Java experience from enterprise backend systems.
Practical data modeling, indexing, query optimization, caching, transactional workflows, and audit-friendly records.
Experience around cloud-hosted systems, deployment surfaces, service environments, and infrastructure-aware application behavior.
Comfortable with release paths, containerized services, infrastructure configuration, deployment confidence, and production troubleshooting.
Worked across microservices, event-driven flows, queues, webhooks, Redis-backed state, and commerce workflow coordination.
Pragmatic architecture decisions around service boundaries, API contracts, data ownership, observability, and maintainability.
Experience validating backend workflows, APIs, critical commerce states, and production fixes with reliability in mind.
Use logs, metrics, traces, errors, dashboards, and monitoring tools to make production behavior diagnosable.
Everyday engineering workflow across Git, package managers, local dev environments, dashboards, API clients, and code review tools.
Systems
Representative patterns behind commerce, catalog, finance, and operational platforms: user workflows, service boundaries, events, storage, and observability.
Frontend
React and Next.js surfaces for storefront, catalog, finance, vendor, and operations workflows.
Keeps complex business tasks usable through stateful UI, validation, and clear workflow progression.
API Gateway
Authentication, routing, validation, request boundaries, rate controls, and integration contracts.
Creates a stable edge between user workflows and domain services.
Microservices
Order, checkout, cart, catalog, wallet, finance, CMS, customer, and operational domains.
Separates ownership while preserving business correctness across service boundaries.
Kafka
Event-driven workflows and asynchronous coordination for downstream business processes.
Moves non-blocking work out of the request path while keeping state changes traceable.
Redis
Caching, transient state, queue-adjacent workflows, locks, and fast lookup paths.
Improves latency and coordinates short-lived state without overloading primary storage.
PostgreSQL
Transactional data, audit records, reporting foundations, and workflow state.
Protects correctness for money, orders, catalog, settlement, and operational records.
Observability
Grafana, OpenTelemetry, Sentry, New Relic, metrics, logs, traces, and dashboards.
Makes production behavior explainable across services, queues, APIs, and user symptoms.
A representative flow connecting storefront state to checkout, payment orchestration, wallet, shipping, order creation, and post-order observability.
A catalog platform path where product data moves through validation, enrichment, audit tracking, Shopify sync, and operational dashboards.
Engineering Philosophy
I prefer architecture that keeps business rules visible. Service boundaries, API contracts, and data models should make the domain easier to reason about, not hide it behind layers of cleverness.
Scalability is usually a set of precise choices: index the right read path, queue the right workload, cache the right state, and split the right ownership boundary only when the product pressure justifies it.
Maintainable code is code that lets another engineer safely change a critical workflow six months later. I value explicit naming, boring control flow, focused abstractions, and tests around business risk.
Performance work starts with measurement. I look for query plans, cache behavior, payload size, queue pressure, and user-facing latency before deciding whether the answer is code, data, infrastructure, or product flow.
A production system should tell a useful story when it fails. Logs, metrics, traces, dashboards, and alerts should connect symptoms to service boundaries quickly enough for engineers to act.
Good developer experience is operational leverage. Clear local setup, readable APIs, useful dashboards, and stable release paths let teams move faster without creating hidden support cost.
Reliability means designing for retries, partial failure, idempotency, audit trails, and clear recovery paths. The goal is not a system that never breaks; it is a system the team can trust and repair.
Leadership
This section captures leadership already present in the resume and leaves room for LinkedIn-only community details when accessible.
Owned commerce and internal platform workflows where product correctness, service reliability, observability, and operational clarity mattered. I focus on making ownership explicit: what the service guarantees, what failure looks like, and how the team will debug it later.
Mentored engineers through implementation tradeoffs, code reviews, debugging patterns, and system behavior discussions. My review style is practical: clarify the contract, protect edge cases, reduce accidental complexity, and leave the code easier to operate.
Worked closely with finance, catalog, operations, product, and engineering teams to convert ambiguous workflows into dependable software. The engineering value is in asking enough business questions to design fewer, better abstractions.
Contributed to architecture and design conversations around distributed commerce, PIM, vendor systems, settlements, and observability. I care about boundaries, data ownership, rollback paths, auditability, and what the system teaches engineers during incidents.
Worked on systems close to revenue, finance, catalog velocity, and operations effort. That means engineering decisions are evaluated not only by code quality, but by whether they reduce manual work and make teams faster.
Participated in service decomposition, integration planning, observability instrumentation, and API design discussions where small technical choices could affect multiple teams and production workflows.
LinkedIn details not accessible in this session
This section is ready for campus ambassador or student ambassador experience if it exists on LinkedIn. Add organization, event details, community impact, and photos in the data file.
Currently Building
This is the learning edge: practical topics that strengthen production engineering, platform work, and future AI-enabled software systems.
Learning how agentic systems plan, use tools, evaluate outputs, and fit into internal engineering workflows.
Exploring practical LLM application architecture, prompt design, retrieval patterns, and reliability tradeoffs.
Building fluency for service-oriented backend development, concurrency, and cloud-native tooling.
Studying ownership, performance, and systems-level thinking through small, focused experiments.
Deepening patterns around distributed consistency, event-driven workflows, reliability, and scaling tradeoffs.
Improving Kubernetes, Terraform, observability, deployment strategy, and production operations depth.