Ahmed Barakat
Frontend Developer
TypeScript
Node JS
JavaScript
API Design: 4/10
Data Layer & Database: 4/10
Security & Auth: 4/10
Active 2 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
Full-stack web developer (Middle) focused on building Next.js/Prisma backend features with strong practical implementation of transactional e-commerce flows. The strongest proven skill is backend e-commerce APIs, demonstrated by order creation with prisma.$transaction (src/app/api/orders/route.ts) which checks stock, atomically updates stock, and clears the cart. There is little or no public evidence of blockchain, smart contract, audits, formal tests, or advanced deployment/ops automation in the available code.
Phone
Technical skills
TypeScript
Node JS
JavaScript
Node JS
Prisma
Frontend
React.js
Next.js
Tailwind CSS
Bootstrap
npm
PostCSS
DevOps
GitHub
Rest API
Git
Vercel
Databases
PostgreSQL
Projects
Front-End Developer with a Bachelor’s Degree in Computer Science and hands-on experience building responsive and interactive web applications using React.js and Next.js. Skilled in developing reusable components, responsive interfaces, e-commerce platforms, API integration, authentication, and user-focused web experiences. Experienced with TypeScript, Tailwind CSS, Prisma, PostgreSQL, Git, GitHub, and Vercel. Strong problem-solving and debugging skills with a focus on clean, maintainable code. Seeking a Junior Front-End Developer position focused on building modern and responsive web applications
Next.js
Prisma
TypeScript
Tailwind CSS
Timeline
Banha University
Bachelor's Degree •
computer science
Middle Backend Developer
Confidence: Medium API Engineer
API engineer (middle level) focused on building REST endpoints for e-commerce flows with a strength in practical end-to-end request handling. The strongest proven skill is transactional order and inventory logic implemented with Prisma ($transaction) in src/app/api/orders/route.ts. There is limited evidence of automated tests, CI/CD, observability/metrics, pagination/caching, or advanced production resilience patterns.
API Design
4/10
How well APIs are designed
Reasonable REST API design with input validation, role separation and consistent error responses, but no explicit versioning, idempotency keys or pagination strategy.
Evidence
src/app/api/orders/route.ts: POST implements order creation with validation and returns appropriate status codes
src/app/api/cart/route.ts: GET and POST include authentication checks, input validation and clear error responses
src/app/api/admin/orders/route.ts: PATCH validates allowedStatuses and returns consistent errors
Data Layer & Database
4/10
Working with databases
Uses Prisma ORM with transactional operations and upsert patterns; demonstrates awareness of atomic updates but no visible migration history or advanced SQL tuning.
Evidence
src/app/api/orders/route.ts: prisma.$transaction used to create order, decrement product stock, and clear cart atomically
src/app/api/cart/route.ts: prisma.cart.upsert and cartItem.create/update usage for cart management
Scalability & Performance
2/10
Handling load and speed
Basic correctness for DB operations and transactions but no caching, queueing, rate-limiting, or explicit connection-pool tuning and no performance measurement artifacts.
Evidence
src/app/api/orders/route.ts: transactional order flow (prisma.$transaction) shows correctness but no queue/caching
package.json: dependencies include @prisma/adapter-pg and pg indicating standard DB stack without added scaling artifacts
System Architecture
2/10
Overall system structure
Monolithic Next.js routing with reasonable module separation (admin vs public APIs); lacks multi-service decomposition, config/secret management patterns, or documented inter-service contracts.
Evidence
src/app/api/admin/* and src/app/api/*: clear folder-based separation of admin and public endpoints
src/app/api/*/route.ts: route-based API organization inside a single Next.js application
Security & Auth
4/10
Protecting data and access
Authentication and role checks are implemented (JWT via jose, cookie-based token), and input validation is present; however there is an insecure fallback JWT secret and no refresh/revocation lifecycle shown.
Evidence
src/app/api/cart/route.ts: jwtVerify(token, JWT_SECRET) with cookie-based token retrieval and payload id checks
src/app/api/admin/users/[id]/route.ts: getAdminId function verifies role === 'ADMIN' before allowing admin actions
Reliability & Observability
2/10
Stability and monitoring
Basic error logging and try/catch handling exist but no structured logging, correlation ids, metrics, retries/backoff, timeouts or graceful shutdown patterns are evident.
Evidence
src/app/api/cart/route.ts: console.error("GET /api/cart error:", error) used for error logging
src/app/api/orders/route.ts: console.error("POST /api/orders error:", error) and try/catch in endpoints
Expertise
Microservices & API Architecture• Middle
Node.js• Middle
Industries
Commerce• Middle
Technologies
Node JS• Middle
Rest API
Prisma
Recommendations
- Develop small-to-medium e-commerce backend APIs: cart, orders, inventory, and admin controls (extend current transactional flows).
- Implement and harden auth lifecycle and security - add secure env handling for JWT secret, refresh/revocation, and rotateable tokens.
- Add observability and reliability work: structured logging, metrics, request tracing, and graceful shutdown patterns.
- Add performance and scalability improvements: introduce caching for product lists, background workers or queues for heavy tasks (email, invoice generation), and pagination where appropriate.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Blockchain Developer
Confidence: Medium Generalist
Full-stack web developer (Middle) focused on building Next.js/Prisma backend features with strong practical implementation of transactional e-commerce flows. The strongest proven skill is backend e-commerce APIs, demonstrated by order creation with prisma.$transaction (src/app/api/orders/route.ts) which checks stock, atomically updates stock, and clears the cart. There is little or no public evidence of blockchain, smart contract, audits, formal tests, or advanced deployment/ops automation in the available code.
Smart Contract Development
Writing smart contracts
Not evidenced in public code
Security & Audit
3/10
Checking contracts for flaws
Basic backend security patterns are applied: JWT auth checks, role-based access checks, input validation, try/catch error handling and transactional DB updates, but there is no evidence of formal auditing, fuzz/invariant tests, or advanced threat modeling.
Evidence
eltmsa7/src/app/api/cart/route.ts: jwtVerify usage, cookie token checks, input validation and error handling
eltmsa7/src/app/api/orders/route.ts: prisma.$transaction for order creation, stock checks and atomic stock decrement + cart clearing
eltmsa7/src/app/api/admin/users/[id]/route.ts: getAdminId role-checking pattern and protections (prevent deleting current admin)
Blockchain Protocol Understanding
Knowing how blockchains work
Not evidenced in public code
DApp & Web3 Integration
Connecting apps to blockchain
Not evidenced in public code
Tokenomics & DeFi Logic
Token and finance logic
Not evidenced in public code
Decentralization & Trust Model
Designing trust without middlemen
Not evidenced in public code
Industries
Commerce• Middle
Recommendations
- Build or extend e-commerce backend features: payments integration, order lifecycle (webhooks) and admin reporting using Next.js API routes and Prisma transactions.
- Harden the backend by adding automated tests (unit and integration), CI pipeline that runs them, and invariant tests around ordering and stock decrement logic.
- Implement production-ready security and deploy practices: rotate JWT secrets, remove insecure defaults, add rate-limiting, structured logging, and a documented migration/deploy process for Prisma.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium Fullstack
Fullstack web developer (approx mid-level) focused on building small-to-medium e-commerce flows and static portfolio sites with practical server-side integration. The strongest proven skill is server-state and data integrity handling backed by concrete artifacts such as src/app/api/orders/route.ts which uses prisma.$transaction to create an order, decrement stock and clear the cart atomically. The public code shows limited measured performance work, limited accessibility features on custom widgets, and sparse client-side React component evidence.
UI Component Architecture
2/10
How interface parts are built
Basic component and CSS architecture with standalone modules and handcrafted HTML pages but no evidence of a deliberate component library, composition patterns or custom hooks for UI lifecycle.
Evidence
elwadyTank/src/app/component/Navbar/Navbar.module.css: CSS module for navbar components
Portfolio/index.html: handcrafted HTML structure for the portfolio site
elwadyTank/src/app/component/Home/Home.module.css: modular styles for a homepage component
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive layouts implemented with media queries and multiple breakpoints; shows practical cross-device considerations but no advanced techniques like container queries or explicit RTL tooling beyond Arabic copy.
Evidence
elwadyTank/src/app/component/Home/Home.module.css: multiple @media rules for several breakpoints
elwadyTank/src/app/services/Services.module.css: responsive rules and layout adjustments
Portfolio/css/style.css: responsive rules and mobile nav handling
Performance Optimization
1/10
Speed of the interface
Little to no evidence of measured performance work, code-splitting, bundle analysis, or advanced runtime optimizations; some suboptimal patterns (interval-driven DOM updates) are present.
Evidence
Portfolio/js/main.js: setInterval used for scroll-triggered UI updates rather than event-driven or throttled handlers
package.json (eltmsa7): Next and React present but no explicit perf artifacts like bundle reports or Lighthouse outputs
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility and semantics work beyond reasonable HTML structure; no ARIA on custom widgets, no focus management or keyboard handling for custom menus is visible.
Evidence
Portfolio/index.html: standard semantic markup for navigation and content but no ARIA attributes
elwadyTank/src/app/component/Navbar/Navbar.module.css: mobile menu visual state exists but no JS-based focus/keyboard management file visible in the analyzed artifacts
State Management & Data Flow
4/10
Managing data in the app
Server-state discipline is the strongest area: authenticated API routes, input validation, role checks, use of prisma transactions and upserts to keep DB state consistent; shows practical understanding of race conditions at the DB level though client-side async discipline is not visible.
Evidence
eltmsa7/src/app/api/orders/route.ts: uses prisma.$transaction to create an order, decrement stock and clear cart atomically
eltmsa7/src/app/api/cart/route.ts: upsert cart per user and handles existing cartItem updates with stock checks
eltmsa7/src/app/api/admin/users/[id]/route.ts: role-based admin checks and input validation before updates/deletes
UX & Visual Polish
3/10
Look and feel quality
Good visual polish and responsive styling across pages; UX patterns like mobile nav, animated skill bars and feedback on form submission exist, but there are limited progressive loading states, skeletons or explicit undo/rollback UX.
Evidence
Portfolio/css/style.css: polished responsive presentation, nav and portfolio card interactions
Portfolio/js/main.js: form submission handling, UI feedback message, mobile nav show/hide implementation
elwadyTank/src/app/component/Trust/Trust.module.css: hover and transform polish for partner cards
Expertise
React• Junior
HTML & CSS• Junior
Modern Web Frameworks• Junior
Industries
Commerce• Middle
Technologies
JavaScript
TypeScript• Junior
Tailwind CSS
Next.js
Vercel
Bootstrap
Git
React.js
npm
PostCSS
GitHub
Recommendations
- Lead development of an e-commerce BFF or API layer (orders, cart, stock) where transactional correctness matters - the code shows direct experience with those flows.
- Polish frontend interactions into React components and migrate repeated CSS modules into a small component library (improves reuse and testability).
- Add automated tests and CI checks for API routes and database migrations to solidify the operational safety of transactional code paths.
- Invest in accessibility (keyboard/focus, ARIA) and measured performance (Lighthouse audits, bundle analysis) before attempting large-scale SPA conversions.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: