Skip to main content

Full-Stack Engineer · Berkeley EECS

Yaman Tarakji

SaaS Founder. 4+ Years in Production. Berkeley EECS '25.

I build things that ship. And then I maintain them.

I started writing professional code in Jeddah in 2016, four years before I ever set foot in a Berkeley lecture hall. Since then I've founded a live multi-tenant SaaS, built internal tooling at scale, and worked across the full stack from PHP backends and MySQL optimization to JavaScript frontends and CI/CD pipelines. I'm looking for a team where backend correctness and system design actually matter.

View Résumé Get in Touch

About Me

I didn't follow the standard path into software engineering, and that's part of what makes me a better engineer.

I started my career as a web developer at a technology company in Jeddah, Saudi Arabia, where I spent four years building production systems for real clients (e-commerce integrations, event management platforms, internal CRMs) without a safety net. No senior engineer reviewing my architecture decisions. No coursework to fall back on. Just requirements, a deadline, and the internet. That experience taught me something university alone can't: how to ship.

"When I decided to go back to school and pursue a formal CS degree at UC Berkeley, I wasn't starting from zero. I was bringing four years of production experience into one of the most rigorous engineering programs in the country."

Berkeley gave me the vocabulary and the theoretical depth to understand why things work the way they do. CS161 (Security), CS164 (Compilers), CS61C (Computer Architecture): these courses changed how I think about every system I build. But I was also the person in the room who had already debugged a broken Shopify API integration at 2am for a client who needed invoices to go out by morning.

The project I'm most proud of is QueryQode CRM, a multi-tenant SaaS I've been building since 2020 that started as a one-client tool for my cousin's business and grew into a live product serving real organizations daily. I made every architectural decision: the RBAC model, the audit logging, the async API design. It's not a side project. It's a product.

At this point I've been both the person who owns a product end-to-end and the person who shows up to a team, reads the codebase, and tries to make it better. I think I'm genuinely good at both. I'm looking for a team building something real where backend correctness and system design matter, and where I'll be expected to own things.

Work Experience

QueryQode CRM
Founder & Full-Stack Developer

Remote – Present

My cousin runs an education consulting business, and after watching him struggle to manage his agent network and student pipeline across spreadsheets and disconnected tools, I built him a CRM. That one-client solution grew into QueryQode, a full multi-tenant SaaS product I've been actively developing since 2020. It's a single-page application with a PHP/MySQL backend, serving a live multi-tenant environment across multiple offices with different roles, permissions, and data boundaries. Every architectural decision, from the RBAC model to the audit log schema to the async API design, was made and owned by me.

The system handles real business operations every day, which means correctness, performance, and data integrity aren't academic concerns.

  • Multi-tenant SaaS serving 5 offices, 54 users, 323 sub-agents, 11,200 leads, and 13,779 enrolled students in production
  • Async API layer reduced action latency from ~2-4s to ~300-600ms via SQL indexing and preloaded reference data
  • Three-tier RBAC (admin / employee / sub-agent) with per-user operation-level permissions and financial data isolation
  • Audit logging system capturing before/after field diffs, user identity, timestamp, and operation type
  • Per-sub-agent lead capture with unique landing pages, UTM parameter tracking, auto-reply emails, and commission attribution
queryqode.com/crm
Small Business Incubator Program, San Diego Mesa College
Web Developer (Independent Contractor)

Remote – Present

San Diego Mesa College runs a small business incubator program that pairs local businesses with student developers. I work as an independent contractor on the web development side, managing each client engagement end-to-end: requirements, build, and a year of post-launch support. Nine clients delivered, two currently active. I also built the CMS framework that powers all of them, a reusable PHP/JavaScript system that gives non-technical business owners control over their content without touching code.

  • Delivered 9 client websites end-to-end, managing each engagement from requirements through 1-year post-launch support in approximately 30 hours per project
  • Built a reusable PHP/JS CMS with SEO fields, form submission handling, brand/color controls, and navigation CRUD, deployed across all 9 client sites
  • Integrated third-party services including Calendly and custom header code injection support
Live sites snaxican.com elegantlymodest.com trusscare.com intuilumina.com
UC Berkeley: CS169A Software Engineering
Tutor / Course Staff

Berkeley, CA Summer 2025, Fall 2025

CS169A is Berkeley's flagship software engineering course, covering Rails, Agile methodology, and behavior-driven development. I joined the course staff to support students building real team projects, spending time in office hours and helping maintain course infrastructure, including refining the GitHub repository provisioning scripts that cut per-semester setup from 3 hours to 15 minutes.

  • Ran office hours for 35 student teams, diagnosing architectural issues in live Rails applications, reviewing test suites, and guiding teams through Agile delivery from design to deployment
  • Refined and maintained course automation scripts for GitHub repo provisioning, reducing setup time from 3 hours to 15 minutes
New Style Technology
Web Developer

Jeddah, Saudi Arabia –

This is where I became an engineer. For four years I was the person on the other side of the client call: the one who took the requirements, made the architecture decisions, built the system, and shipped it. No team to hand things off to. E-commerce integrations, event platforms, accounting automation, enterprise tooling. The clients were real businesses paying for working software, and that pressure teaches you things that nothing else does.

  • Built an API bridge between a SQL Server-based Windows accounting system and both Shopify and OpenCart, automating invoice generation for hundreds of daily transactions and eliminating ~1 minute of manual data entry per transaction
  • Designed and shipped a full event management and ticketing platform: online registration, Payfort payment integration, automated ticket and certificate generation, and integrations with Kajabi, InfusionSoft, and Shopify, creating a unified operational hub where previously disconnected systems existed
  • Automation reduced post-event attendee processing from ~30-45s per entry to ~5s per entry, cutting required staffing from 3-4 employees to 1 monitor
  • Built an internal CRM for a public accounting firm with live notifications, full CRUD for client and memo management, and a clean multi-user interface

Projects

A selection of professional, team, and academic work.

QueryQode CRM: dashboard interface illustration

Solo / Professional · Founder · 2020 – Present

QueryQode CRM

A multi-tenant CRM I designed, built, and operate for education consultancies managing sub-agent networks and student enrollment pipelines. Live in production, serving real users daily, from lead capture with UTM tracking to financial reporting with role-scoped data visibility.

PHP JavaScript MySQL SPA RBAC REST APIs Bootstrap
queryqode.com/crm
Flextensions: Berkeley extension request platform illustration

Team Project · UC Berkeley CS169A · Feb 2025 – May 2025

Flextensions

A UC Berkeley platform for students to request assignment extensions through a unified interface integrated with Canvas and Gradescope. I contributed the core student-facing request workflow (Forms MVC, alerts, email notifications, responsive data tables), drove test coverage from ~10% to 80%, and reduced per-request review time from ~30-45s to ~2-5s.

Ruby on Rails Canvas API Gradescope RSpec Cucumber GitHub Actions
flextensions.berkeley.edu
Secure File Sharing System: cryptographic network illustration

Academic · UC Berkeley CS161: Computer Security

Secure File Sharing System

A cryptographically secure file storage and sharing system written in Go, supporting multi-user sharing and permission revocation under an adversarial threat model. Implemented 8 core user-facing functions using cryptographic primitives (encryption, MACs, digital signatures), reasoning carefully about every trust boundary. CS161 changed how I read other people's code.

Go Encryption MACs Digital Signatures Adversarial Design
Project Spec
OCaml Compiler: compilation pipeline illustration with lambda symbol

Academic · UC Berkeley CS164: Compilers

OCaml Compiler

A compiler for a Lisp-like S-expression language, written entirely in OCaml. Parses S-expressions, generates x86 assembly, and produces executable output via a small C runtime. Implemented constant folding as a compiler optimization pass. Building this gave me ground-level understanding of how high-level code becomes machine instructions, something that now informs how I think about performance at every layer.

OCaml x86 Assembly C Runtime Constant Folding
Class Compiler
RISC-V CPU: chip with circuit trace illustration

Academic · UC Berkeley CS61C: Computer Architecture

RISC-V CPU

Designed and implemented a functional CPU from scratch in Logisim capable of executing the RISC-V instruction set, building the datapath, control logic, ALU, and memory interface by hand. It's the kind of project that makes you a better software engineer even when you're not writing hardware.

Logisim RISC-V ISA Digital Logic CPU Datapath
Project Spec
S1XT33N: voice-controlled robot car illustration

Academic · UC Berkeley EECS 16B

S1XT33N: Voice-Controlled Robot Car

Built and debugged analog circuitry for a voice-controlled robot car as the capstone project for EECS 16B. The car used a microphone and signal processing pipeline to classify voice commands and control motor output. This sits at the intersection of analog circuit design, sensing, and feedback control, a different kind of problem-solving than pure software.

Analog Circuits Op-Amps Signal Processing Feedback Control Arduino
Course Website

Skills

Languages
JavaScript Python PHP SQL Ruby Go Java C / C++ OCaml
Frameworks
FastAPI Node.js / Express Ruby on Rails React Bootstrap
Databases
MySQL SQL Server MongoDB Oracle
Tools & Infra
Git / GitHub GitHub Actions Docker Linux Heroku Webpack
Testing
RSpec Cucumber
Other
RBAC / Authorization Multi-tenant SaaS Audit Logging Third-party Integrations

AI in My Workflow

I use Claude Code in the terminal as an active part of how I build software. I typically start by drafting a feature spec and iterating with Claude to clarify the problem, evaluate options, and outline an implementation strategy. From there, I move into development, using Claude to generate scaffolding, accelerate repetitive tasks, and help break larger problems into manageable steps. I treat AI as a practical collaborator in the workflow, while still reviewing, refining, and owning the final implementation myself.

Terminal window showing Claude Code in use

Education

University of California, Berkeley
B.S. Electrical Engineering & Computer Sciences (EECS)

Awarded:

Relevant Coursework

  • CS 61A: Structure & Interpretation of Computer Programs
  • CS 61B: Data Structures
  • CS 61C: Machine Structures
  • CS 70: Discrete Math & Probability
  • CS 161: Computer Security
  • CS 164: Programming Languages & Compilers
  • CS 168: Internet Architecture
  • CS 169A/L: Software Engineering
University of California, Berkeley, B.S. EECS degree certificate (sample placeholder)
San Diego Mesa College
Associate of Arts: Liberal Arts & Sciences, Mathematics & Pre-Engineering (Computer Science)

High Honors

Relevant Coursework

  • CISC 190: Java Programming
  • CISC 192: C/C++ Programming
  • CISC 179: Python Programming
  • CISC 187: Data Structures in C++
  • CISC 191: Intermediate Java Programming
  • CISC 211: Computer Organization & Assembly Language
  • WEBD 164: JavaScript for Web Development
  • WEBD 171: Advanced JavaScript
A.A. Degree
Associate in Science for Transfer: Mathematics

High Honors

Relevant Coursework

  • MATH 150: Calculus/Analytic Geometry I
  • MATH 151: Calculus/Analytic Geometry II
  • MATH 252: Calculus/Analytic Geometry III
  • MATH 254: Intro to Linear Algebra
  • MATH 245: Discrete Mathematics
  • MATH 255: Differential Equations
  • PHYS 195: Mechanics
  • PHYS 196: Electricity & Magnetism
A.S. Degree

Résumé

A full picture of my experience, education, and technical skills. One page, no fluff.

View Résumé Download PDF

Let's Talk

I'm actively looking for full-time software engineering roles, backend-heavy or full-stack,, in the Bay Area or remote. If you're working on something interesting and think I might be a fit, I'd genuinely like to hear about it. I'm also happy to connect if you're a student navigating Berkeley's CS curriculum, a founder thinking through an early product, or just want to talk shop.

The best way to reach me is email.

Email yaman@queryqode.com LinkedIn linkedin.com/in/ytarakji GitHub github.com/ytarakji

What I'm Open To

Full-time SWE roles (new grad / early career) Backend or full-stack engineering Remote or Bay Area (SF / Berkeley) Startups and established engineering teams