Khalid Rouissi
Rust
TypeScript
Go
Active 2 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A Middle-level backend/API engineer focused on developer tooling and localization infrastructure with solid CLI and CRUD service work. The strongest proven skill is building a modular Rust CLI for i18n scanning and planning, backed by Tarjemni modules such as src/scan.rs, src/detect.rs and src/placeholders.rs and accompanying unit tests. The public code lacks production-grade operational patterns like secure secret management, transaction handling, migration history and resilience engineering.
Technical skills
Rust• Middle
TypeScript• Junior
Go• Middle
Rust
Cargo
Clap
Serde
Anyhow
Go
GORM
Databases
PostgreSQL
DevOps
Rest API
Middle Backend Developer
Confidence: Medium API Engineer
A Middle-level backend/API engineer focused on developer tooling and localization infrastructure with solid CLI and CRUD service work. The strongest proven skill is building a modular Rust CLI for i18n scanning and planning, backed by Tarjemni modules such as src/scan.rs, src/detect.rs and src/placeholders.rs and accompanying unit tests. The public code lacks production-grade operational patterns like secure secret management, transaction handling, migration history and resilience engineering.
API Design
3/10
How well APIs are designed
Basic REST API design and endpoint surface are implemented with tests and consistent JSON error responses, but there is no explicit versioning, no idempotency keys, limited pagination/filtering design and no formal error contract beyond ad-hoc JSON maps.
Evidence
WebCraft/Server/controllers/projectsController.go: CreateProject/GetProject/UpdateProject/DeleteProject handlers
WebCraft/Server/controllers/authController.go: Login/User/Logout endpoints and cookie handling
WebCraft/Server/controllers/project_controller_test.go: tests exercising POST/GET/PUT/DELETE endpoints
Data Layer & Database
2/10
Working with databases
Data layer uses GORM with a central connection initializer and AutoMigrate, and controllers interact with the DB, but there is no migration history, no explicit transaction handling or isolation-level awareness and no evidence of hand-tuned SQL or index considerations.
Evidence
WebCraft/Server/database/connection.go: Connect uses gorm.Open and AutoMigrate
WebCraft/Server/controllers/projectsController.go: direct GORM CRUD calls (Create, Where/First, Save, Delete)
WebCraft/Server/controllers/project_controller_test.go: mock DB interactions for persistence behavior
Scalability & Performance
1/10
Handling load and speed
Almost no scalability or performance-specific patterns are present; no caching, queueing, rate limiting, connection pooling tuning, or measured optimizations are visible beyond reasonable library choices.
Evidence
Tarjemni/src/scan.rs: uses WalkDir to traverse files (single-process scan)
WebCraft/Server/go.mod: standard server dependencies (no explicit performance tuning artifacts)
System Architecture
3/10
Overall system structure
Code is modular and separated (Rust CLI modules, Go controllers, database package), showing deliberate folder boundaries and small components, but there is no evidence of multi-service decomposition rationale, service contracts or production-grade config/secret management beyond dotenv usage.
Evidence
Tarjemni/src/{scan.rs,detect.rs,translate.rs,placeholders.rs}: clear module separation for CLI functionality
WebCraft/Server: controllers/, database/ and routes/ structure and main.go entry point (project organization)
Security & Auth
2/10
Protecting data and access
There is basic authentication implemented (JWT cookies) showing awareness of auth flows, but security practices are weak (hardcoded secret, cookies not HTTPOnly, SameSite set to None) and there is no token revocation, rotation, input sanitization guidance or dependency audit evidence.
Evidence
WebCraft/Server/controllers/authController.go: JWT usage with SecretKey constant and cookie creation (HTTPOnly=false, SameSite=None)
WebCraft/Server/controllers/projectsController.go: relies on GetUserIDFromCookie for auth gating
Reliability & Observability
2/10
Stability and monitoring
There is some test coverage (unit tests in Rust and Go controller tests) and use of anyhow for error contexts, but operational reliability patterns (timeouts with backoff, graceful shutdown, structured logging with correlation ids, metrics/alerts) are not present.
Evidence
Tarjemni/src/*: #[cfg(test)] unit tests in scan.rs and placeholders.rs demonstrating attention to correctness
WebCraft/Server/controllers/project_controller_test.go: tests that validate handler behavior and mock DB
Expertise
Rust• Middle
Go Development• Middle
Databases & Vector Storage• Middle
Industries
Software• Middle
Technologies
Go• Middle
PostgreSQL
Rest API
GORM
Recommendations
- Build CLI-first localization pipelines and agent integrations (expand the Tarjemni adapter boundary to real providers and add end-to-end tests).
- Harden and evolve the API service by adding secure secret management, HTTPOnly cookie flags, token refresh/revocation and formal error contracts.
- Add database migration history (versioned migrations), explicit transactions where needed, and simple performance tests or caching strategies for hotspots.
- Extend observability: add structured logging with request correlation, metrics and graceful shutdown/timeout handling for long-running operations.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Game Developer
Confidence: High Generalist
Middle-level generalist developer specializing in localization and regional data validation tooling. The strongest proven skill is building localization and content-pipeline tooling, exemplified by the Rust CLI scan/persist/translate flow (Tarjemni src/scan.rs, src/placeholders.rs and src/translate.rs). There is no evidence of game-engine work, graphics/shader development, deterministic simulation, netcode, or frame-budget optimizations in the public human-authored code.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
Drawing game visuals
Not evidenced in public code
Physics & Math
Game physics and math
Not evidenced in public code
Engine Proficiency
Skill with the game engine
Not evidenced in public code
Performance & Frame Budget
Keeping the game smooth
Not evidenced in public code
Content Pipeline & Tooling
4/10
Tools for game content
Clear, human-authored tooling and content pipeline work for localization and scanning: a Rust CLI with scanning, persistence, dry-run/report modes, placeholder extraction and translation plan stubs; well-structured modules and tests indicate practical tooling focus.
Evidence
KhalidRouissi1/Tarjemni/src/scan.rs: collect_strings, persist_scan, scan_cache_path and run functions implementing file scanning and cache persistence
KhalidRouissi1/Tarjemni/src/placeholders.rs: extract_placeholders and placeholders_match implementations with tests
KhalidRouissi1/Tarjemni/src/translate.rs: run and apply functions implementing translation planning and dry-run output
Technologies
Rust• Middle
Serde
Anyhow
Cargo
Clap
Recommendations
- Develop CLI-based localization and i18n tooling, including scan/persist flows and placeholder-preserving translation pipelines.
- Implement and extend regional validation libraries and utilities (phone, CIN, RIB, car plates) with strong test coverage and packaging for npm/crates.
- Integrate translation provider adapters behind a pluggable trait/interface and add reproducible CI for publishing artifacts.
- Build developer-facing dry-run/reporting features and editor integrations for localization workflows (e.g., VS Code extension or pre-commit hooks).
Junior Frontend Developer
Confidence: Medium Generalist
Generalist frontend and TypeScript engineer (middle level) focused on practical developer tools and polished static UI implementations. The strongest proven skill is building tested TypeScript validation utilities, as shown by the validation logic and test suites in the validators and car-plate.test.ts. There is limited public evidence of complex SPA architecture, advanced performance engineering, backend system design or automated accessibility tooling.
UI Component Architecture
2/10
How interface parts are built
Minimal component architecture; work is split between a TypeScript utility library and a static HTML/CSS portfolio without a component-based UI system.
Evidence
portfolio/index.html: sectioned semantic HTML layout (header, landing, aboutMe, featured projects)
portfolio/style/main.scss: SCSS structure and grouped rules for layout and modular sections
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive layout using media queries, grid and flex; basic mobile breakpoints and sensible fallbacks are present.
Evidence
portfolio/style/main.css: multiple @media rules and mobile adjustments
portfolio/style/main.scss: grid-based layout, grid-template-areas and responsive sections
Performance Optimization
1/10
Speed of the interface
Little to no evidence of measured performance work, bundle analysis, code-splitting, or virtualization optimizations.
Evidence
degachejs/package.json: build and test scripts (tsdown, vitest) but no bundler metrics or analyzer artifacts
portfolio/style/main.scss: CSS animations exist but no prefers-reduced-motion handling or documented perf tradeoffs
Accessibility & Semantics
3/10
Usable for everyone
Basic semantic HTML and image alt attributes are present, but no ARIA on custom widgets, no keyboard focus management, and no a11y automation in CI.
Evidence
portfolio/index.html: semantic sections and img alt attributes for portfolio images
portfolio/style/main.css: layout and visibility rules but no focus management or ARIA-specific styles
State Management & Data Flow
2/10
Managing data in the app
State and data-flow work is limited to synchronous utility functions and validation logic; no async state discipline, request cancellation, optimistic updates or state machines observed.
Evidence
degachejs/src/validators/car-plate.ts: pure synchronous validation and normalization functions
degachejs/src/constants/regions.ts: static mappings and POSTAL_CODES_MAP constructed synchronously
UX & Visual Polish
4/10
Look and feel quality
Good visual polish for a static portfolio site with animations and hover effects; loading/error/stale states and advanced UX patterns are not present for complex apps.
Evidence
portfolio/style/main.css: landing animations, hover transitions and visual polish
portfolio/index.html: structured featured projects, project cards and visual sections
Verified artifacts
Expertise
HTML & CSS• Junior
Industries
Financial Services• Junior
Technologies
TypeScript• Junior
Recommendations
- Author and maintain small-to-medium TypeScript utility libraries and validation packages for npm distribution and documentation.
- Build and harden form validation, localization and input normalization for regional markets, leveraging the existing synchronous validators and tests.
- Design and implement static marketing and portfolio sites or small marketing apps where polished CSS and responsive layouts are primary requirements.
- Expand into component-based UI libraries or SPA work by extracting UI sections into reusable components and adding accessibility and state-management patterns
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: