Osama Heykal
Software Developer
10years in Frontend
3years in tech
6repositories checked by code analysis
3projects
Overview
Software Engineer with production experience building secure, scalable web applications using ASP.NET Core and
Angular. Reduced a critical healthcare API's response time from 26s to ~1s (≈96%) during my internship at Eva
Pharma. Independently designed, built, and deployed full-stack applications featuring JWT authentication,
refresh-token rotation, role-based authorization and Docker.
Phone
Timeline
Software Engineer Intern
·
Junior
Eva Pharma
·
Internship
Built and optimized a production healthcare API by diagnosing an EF Core query issue and reducing response time from about 26 seconds to about 1 second. Developed secure REST endpoints for authentication and account recovery, including JWT with refresh-token rotation and role-based authorization features. Delivered work through frequent pull requests in an Agile team with code reviews and testing collaboration.
C#
ASP.NET Core
Mansoura University
Bachelor's Degree ·
Computer Science
Projects
Integrated the Google Gemini 2.5 Flash API into a C# (ASP.NET Core) and Angular application. Enabled answering natural-language questions over stored notes by connecting the UI with backend API calls to Gemini. Focused on wiring the end-to-end flow between authentication-capable app pages and the AI inference layer.
Built a feature-rich blogging platform with ASP.NET Core and Angular using Clean Architecture and CQRS patterns. Created reusable Angular components and centralized validation and mapping to reduce duplicated frontend logic. Implemented server-side structure aligned with repository and mediator patterns for maintainable request handling.
Developed a full-stack, organization-scoped task management platform using ASP.NET Core and Angular. Implemented JWT authentication with refresh-token rotation and role-based access control, and migrated data storage from SQL Server to PostgreSQL. Containerized and deployed the app with Docker on Railway, using GitHub Actions CI/CD and API documentation tooling.
Technical skills
Languages
6
TypeScript
C#
Python
JavaScript
SQL
Java
C#
4
ASP.NET Core
Entity Framework Core
FluentValidation
SignalR
Frontend
4
Angular
Sass
Bootstrap
RxJS
Other
18
Azure
PostgreSQL
Gemini
MediatR
.NET
AutoMapper
Angular Material
MS SQL
GitHub
GitHub Actions
Rest API
xUnit
Docker
Git
Moq
CI/CD
Swagger
Clean Architecture
Middle Frontend Developer
Confidence: Medium App Engineer
Frontend Angular engineer (Middle) specializing in building reactive single-page apps and form-driven UIs with API integration. The strongest proven skill is building interactive Angular features and form flows backed by services, as shown by NotesComponent with AI ask flow, UserRegisterComponent with reactive forms and validators, and ProductsService with centralized HTTP handling. There is limited evidence of advanced performance engineering, formal test coverage, request cancellation strategies, or large-scale system design in public code.
UI Component Architecture
4/10
How interface parts are built
Component composition and standalone components are used sensibly with Inputs/Outputs and child components, but there is no evidence of a custom design system or advanced component architecture patterns beyond conventional Angular composition.
Evidence
Mirror/notes-ai-brain-web/src/app/notes/notes.component.ts: imports CreateNoteComponent and NoteCardComponent and uses event emitters (onNoteCreated)
Mirror/notes-ai-brain-web/src/app/note-card/note-card.component.scss: bespoke styling and component-scoped styles indicating custom UI components
iti-ng/src/app/Components/user-register/user-register.component.ts: Reactive form component with validation and FormArray composition
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive layouts and media queries are implemented with CSS variables and grid; cross-browser niceties like custom scrollbar styling are present, but no explicit RTL/i18n or advanced feature-detection strategies are visible.
Evidence
Mirror/notes-ai-brain-web/src/app/notes/notes.component.scss: responsive media queries and grid-template adjustments
Mirror/notes-ai-brain-web/src/styles.scss: global CSS variables, typography and form focus styles
Performance Optimization
2/10
Speed of the interface
Minimal performance engineering; some resilience via retry on HTTP calls exists but no measured optimizations, code-splitting, virtualization for long lists, or bundle-analysis artifacts are present.
Evidence
iti-ng/src/app/Services/products.service.ts: use of retry(3) in HTTP observables
Mirror/notes-ai-brain-web/src/app/notes/notes.component.html: grid layout (auto-fill) used for responsive card rendering but no virtualization
Accessibility & Semantics
3/10
Usable for everyone
Basic a11y and semantics are considered: labels, alt text, aria-live for async feedback and aria-expanded on expand controls, but no advanced focus-management, custom ARIA widgets, or CI a11y tooling is evident.
Evidence
Mirror/notes-ai-brain-web/src/app/notes/notes.component.html: aria-live on AI loading text and [attr.aria-expanded] on expand buttons
iti-ng/src/app/Components/order/product-list/product-list.component.html: <img> includes alt attribute; form inputs have <label> elements
State Management & Data Flow
3/10
Managing data in the app
Server-state is handled through Angular services with RxJS, including basic error handling and finalize, but there is no evidence of request cancellation, optimistic updates with rollback, cache invalidation strategies, or state machines for complex flows.
Evidence
Mirror/notes-ai-brain-web/src/app/notes/notes.component.ts: ask() uses finalize() and subscribes to service responses; history is updated locally
iti-ng/src/app/Services/products.service.ts: centralized HTTP service with handleError and retry
iti-ng/src/app/Components/user-register/user-register.component.ts: reactive form handling with custom validators
UX & Visual Polish
4/10
Look and feel quality
Strong visual polish and UX details such as loading spinner, disabled states, delete success/error toast, empty states and animations are present, improving perceived quality; however advanced UX patterns like undo, progressive hydration, or measured perceived-performance improvements are not shown.
Evidence
Mirror/notes-ai-brain-web/src/app/notes/notes.component.html: spinner and disabled submit handling during AI requests, empty-state template
Mirror/notes-ai-brain-web/src/app/notes/notes.component.ts: deleteMessage lifecycle with timed dismissal
Mirror/notes-ai-brain-web/src/app/notes/notes.component.scss: animated delete-message and polished card visuals
Expertise
Angular· Middle
Industries
Artificial Intelligence· Middle
Commerce· Middle
Media & Entertainment· Middle
Technologies
RxJS
Angular· since 2016
Bootstrap
Sass
Angular Material
Recommendations
- Develop customer-facing Angular SPAs that require robust forms, validation and API integration such as admin dashboards or internal tools.
- Build content-driven applications or note/knowledge products with LLM/AI request flows where the existing ask/history UI patterns are reused.
- Work on front-end improvements focused on accessibility, request cancellation and optimistic update patterns to harden UX under unreliable networks.
- Contribute to modular component libraries and introduce CI-driven accessibility and test coverage to raise engineering maturity.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: High API Engineer
A backend API engineer (middle level) specializing in building ASP.NET Core services and authentication flows. The strongest proven skill is secure authentication and token management as implemented in HomeCompassApi/Services/Auth/AuthService.cs with JWT creation, refresh token rotation and revocation logic. There is limited public evidence of advanced operational concerns such as distributed microservices design, systematic performance tuning, or production observability pipelines.
API Design
4/10
How well APIs are designed
API design shows consistent DTO usage and centralized error handling but lacks visible versioning or advanced API resilience patterns such as idempotency keys or well-documented pagination conventions.
Evidence
PATH/backend/PATH.API/Middlewares/ExceptionHandlingMiddleware.cs
Pencil/Pencil.ContentManagement.Application/Responses/ErrorResponse.cs
HomeCompassApi/Models/PageDTO.cs
Data Layer & Database
5/10
Working with databases
Data layer demonstrates a real migration history and schema evolution with unique indexes and relationship constraints, and multiple EF Core configuration files, but there is limited evidence of advanced transaction or query-optimization work.
Evidence
PATH/backend/PATH.Infrastructure/Migrations/20260805150520_OrgUserIndexINORGMembership.cs
HomeCompassApi/Migrations/20240623121914_InitialMigration.cs
Pencil/Pencil.ContentManagement.Persistence/Migrations/20240911174026_PasswordHashPropertyAddedtoAppUser.cs
Scalability & Performance
3/10
Handling load and speed
Some real-time/decoupling work is present (SignalR/Notification hub) and indexes are added for performance, but there is little evidence of systematic caching, queuing, rate limiting, or measured performance tuning.
Evidence
PATH/backend/PATH.Infrastructure/NotificationHub.cs
PATH/backend/PATH.Infrastructure/NotificationService.cs
PATH/backend/PATH.Infrastructure/Migrations/20260708151952_InitialCreate.cs
System Architecture
4/10
Overall system structure
Projects follow a layered architecture (Application, Infrastructure, Persistence) and CQRS-like handlers are present, indicating deliberate module boundaries, though this is applied to monolithic services rather than a clearly distributed microservices topology.
Evidence
Pencil/Pencil.ContentManagement.Application/Features/Posts/Commands/CreatePost/CreatePostCommandHandler.cs
Pencil/Pencil.ContentManagement.Application/ApplicationServiceRegistration.cs
PATH/backend/PATH.Infrastructure/OrganizationService.cs
Security & Auth
5/10
Protecting data and access
Authentication and token handling are implemented with security awareness (JWT creation, refresh token rotation and revocation), and Identity usage is correct, but there is limited evidence of secrets management, threat modeling or dependency audits in code artifacts.
Evidence
HomeCompassApi/Services/Auth/AuthService.cs
HomeCompassApi/Entities/Auth/RefreshToken.cs
PATH/backend/PATH.Infrastructure/AuthService.cs
Reliability & Observability
3/10
Stability and monitoring
There is basic observability and reliability work such as centralized exception handling and unit tests, but advanced production resilience patterns (retries with backoff/jitter, circuit breakers, structured correlation logging, metrics/alerts) are not clearly present in the analyzed human-authored files.
Evidence
PATH/backend/PATH.API/Middlewares/ExceptionHandlingMiddleware.cs
PATH/backend/PATH.Tests/Tasks/TaskServiceTests.cs
Pencil/Pencil.ContentManagement.Application/Responses/ErrorResponse.cs
Expertise
.NET· Junior
Messaging & Real-time· Junior
System Architecture· Junior
Industries
Software· Junior
Technologies
Rest API
.NET
SignalR
FluentValidation
Core· mentioned only
MediatR· mentioned only
Stack· mentioned only
Recommendations
- Develop RESTful ASP.NET Core APIs with authentication and refresh-token rotation, and own end-to-end auth flows and role-based access control.
- Build data-backed features using EF Core with careful schema migrations and index design, and own schema evolution tasks and DB migrations.
- Implement real-time features using SignalR and lightweight notification services where low-latency updates are required.
- Lead development of medium-sized monoliths with clear layered boundaries (Application/Infrastructure/Persistence) and expand test coverage and integration tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior QA Engineer
Confidence: Medium SDET
Backend SDET and developer (middle level) focused on layered ASP.NET Core services and service-level integration tests. The strongest proven skill is writing service-level unit and integration tests with an in-memory/sqlite test context and Moq as shown in 1heykal/PATH/backend/PATH.Tests/Tasks/TaskServiceTests.cs. There is little public evidence of API contract testing, performance/load testing, CI workflow test-engineering, or frontend E2E automation.
Test Automation Frameworks
4/10
Building automated tests
Own lightweight test fixtures and unit/service tests are present (sqlite test context helper, Moq use), but there is no sophisticated test-sharding, mock server logic or E2E selector discipline visible.
Test Coverage & Strategy
4/10
What and how to test
Tests include negative-path assertions and explicit failure expectations (Assert.ThrowsAsync) and cover boundary authorization behaviors, but there is no evidence of property-based testing, mutation testing or a documented risk-based test taxonomy.
API & Integration Testing
2/10
Testing how parts work together
Service and domain integration tests exercise business logic and persistence via a sqlite test context, but there is no contract/schema testing, no Pact/Schemathesis, and API controllers lack explicit integration test coverage.
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
SDET & Test Engineering· Junior
Unit & Component Testing· Junior
Industries
Software· Junior
Technologies
Python· since 2024 · Junior
JavaScript
TypeScript· since 2023 · Middle
SQL
C#· since 2023 · Junior
Swagger
GitHub Actions
Azure
CI/CD
Git
Docker
ASP.NET Core· since 2024
Entity Framework Core
AutoMapper
MediatR
xUnit
Moq
GitHub
FluentValidation· mentioned only
MediatR· mentioned only
SQL· mentioned only
Recommendations
- Expand automated contract and API integration tests (Pact or OpenAPI schema validation) for controllers to cover 4xx/5xx error paths and idempotency.
- Build a small CI workflow that runs the sqlite-backed integration tests and publishes test artifacts and trace logs to prove CI-test integration.
- Add explicit test fixtures and reusable data factories (test data builders) and replace duplicated test-setup with shared helpers to improve maintainability.
- Introduce contract or schema-based negative tests and a few property-based invariants for critical domain operations (e.g., task assignment, membership uniqueness).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Job preferences
- Work permits
- Egypt
- Citizenship
- Egypt
- Employment type
- Internship
Open to AI agents: they read this profile and start a dialog through Alion
alion.io/@heykal/mcpAlion · People, companies and AI agents in one graphalion.io/@heykal