Skip to content
N
Booting Engineering OS
000%
The Journey

From business development to engineering to founder

Not a straight line from CS degree to dev job. A deliberate arc through business, product, and engineering — where every chapter compounds into the next.

Chapter 01 · Business

Business Development Manager

I didn't start in code — I started in the market. Selling, negotiating, and sitting across the table from customers taught me what businesses actually pay for and where they hurt.

Learned to listen to customer problems before proposing solutions.
Chapter 02 · The Pivot

Moved Into Software Development

I kept seeing problems that software could solve — so I taught myself to build it. React, then the full MERN stack, learned end-to-end while shipping real things.

Turned business intuition into the ability to build the solution myself.
Chapter 03 · Building

Started Building Products

Not features in someone else's roadmap — whole products. Frontend, backend, database, deployment. I learned what it takes to take an idea from zero to something people can use.

Owned products end-to-end, not isolated tickets.
Chapter 04 · Founder

Founded ConnectEdApp

I built and launched an education platform — and ran every side of it. Product, engineering, sales, demos to school administrators, customer discovery, and iterating on real feedback.

Wore every hat: founder, PM, full-stack engineer, sales, customer success.
Chapter 05 · Senior Engineer

Became a Senior Full Stack Engineer

I brought that product-and-customer mindset into senior engineering — architecting distributed systems, accessibility platforms, and developer tooling at scale.

Engineering decisions grounded in product and business impact.
Chapter 06 · Now

Building AI-Powered Developer Tools

Today I'm building AI-native systems — MCP servers, agentic workflows, and tools like Ignix UI — compounding everything I've learned across business, product, and engineering.

Using AI as leverage to build faster and ship more.
The Differentiator

Business thinking + engineering thinking = product thinking

Most engineers know technology. I understand technology, product, sales, customers, and business — and that combination is where real products get built.

Business Thinking

  • Talk to customers, not just stakeholders
  • Validate before building
  • Translate value for non-technical buyers
  • Revenue, retention, and ROI awareness

Engineering Thinking

  • Architect for scale and reliability
  • Clean, maintainable, tested systems
  • Automate and ship continuously
  • Leverage AI to move faster

Product Thinking

  • Build what customers actually need
  • End-to-end ownership, 0 → 1
  • Trade-offs that balance speed & quality
  • Outcomes over output
Technical Architecture

How I build systems

Most developers show projects. Few explain architecture. Here's how I design software that scales, stays reliable, and survives real-world load.

A request's lifecycle
Client
API Gateway
Services
Queue
Workers
Data + Cache

Synchronous work returns fast; heavy or async work is pushed to queues and processed by workers — keeping the API responsive while the system scales horizontally, with metrics and logs on every hop.

Monorepos

TurboRepo workspaces with shared packages, typed contracts, and fast incremental builds.

Microservices

Independently deployable services with clear boundaries and resilient communication.

Distributed Systems

Designing for failure — retries, idempotency, and consistency trade-offs.

Event-Driven Architecture

Decoupled services that react to events instead of tight synchronous chains.

Queue-Based Processing

BullMQ & RabbitMQ for background jobs, fan-out, and high-throughput pipelines.

API Design

Clean REST & GraphQL contracts, versioning, pagination, and predictable errors.

Scalability

Horizontal scaling, caching layers, and load-aware processing under real traffic.

Security

JWT/OAuth, RBAC, input validation, and least-privilege access by default.

CI/CD

GitHub Actions pipelines, Dockerized builds, and automated deployments.

Monitoring

Prometheus + Grafana metrics, structured logging, and actionable alerts.

AI Engineering

The new engineering substrate: AI-native systems

Treat models as first-class collaborators. Wire them into your tooling, your code, your CI — and unlock 10x leverage.

~/engineering-os · agent.session
$ mcp connect
✓ Linked: claude · cursor · github · linear
$ agent run review --pr 412
→ analyzing diff (134 files)
→ found 3 risks, 7 suggestions
→ posting structured review
✓ Done in 12.4s
$ _

Model Context Protocol

Designing MCP servers that expose tools, data, and workflows to AI agents — the API layer for the AI era.

Claude & Claude Code

Production agentic workflows with Claude. Code review, system design, refactors — at engineering scale.

Cursor & AI-assisted IDE

Editor-first AI. Custom rules, prompt libraries, and codegen pipelines that respect taste.

AI Agents

Autonomous workflows that plan, execute, and verify — wired into queues, CI, and human-in-the-loop gates.

Agentic workflow
01
Plan
context · constraints
02
Generate
code · tests · docs
03
Verify
lint · type · review
04
Ship
deploy · rollback
05
Observe
metrics · feedback
Why Work With Me

Not just another MERN developer

A rare combination of founder, engineer, product builder, and AI-native developer — someone who can take an idea all the way to a shipped, customer-validated product.

Product Mindset

I build products, not just features — focused on outcomes and customer value.

Founder Experience

I've founded, launched, and sold a product end-to-end.

Customer Understanding

I've sat with real users, run demos, and shaped products around feedback.

Full Stack Development

Web and mobile, frontend to backend, design to deployment.

Backend Architecture

Distributed systems, queues, microservices, and scalable APIs.

AI Engineering

MCP, agentic workflows, and LLM-powered developer tooling.

DevOps

Docker, CI/CD, AWS, and monitoring — I ship and operate what I build.

Business Background

Sales and BD experience — I speak both engineering and business.

End-to-End Ownership

From idea and validation to launch and iteration, I own the whole loop.

Fast Learning

I went from sales to senior engineer by learning relentlessly.