Software developer in Beirut. Nurse first, then UI/UX designer, now building full-stack systems.
The layers I work across
Every system I build goes from the screen down to the database. Select a layer to hear how I approach it.
And the concerns that cut through every layer:
Featured projects
Two systems I built alone, end to end, and a platform I'm building with a team. Real backends, careful relational models and access control that holds up.
School Management System
In use at one school
A full stack web application with a layered ASP.NET Core API, business rules in SQL Server stored procedures and a React and TypeScript client. It is Arabic-only and right-to-left, and covers a school's students, attendance, subscriptions and reports, plus a portal for parents.
My role: built alone, from scratch to deployment: design, database, API, interface and testing.
How it's built
Controller → Service → Repository → ADO.NET → Stored procedure
React and TypeScript on the front, an ASP.NET Core (.NET 10) API with JWT authentication, and SQL Server underneath. No ORM: business rules live in stored procedures and one service layer.
Modules
Students and groups
Attendance
Progress tracking
Curriculum follow-up
Subscriptions and payments
Planning and notes
Evaluations
Reports and audit log
Engineering details
Four roles (super admin, admin, team leader, teacher) plus limited finance and curriculum accounts. Edit windows are enforced in SQL, archived students stay in the archive with no time limit and can be restored, monthly reports generate automatically, and backups run on a schedule. Read-only answers are cached in memory per person for a few seconds and dropped the moment any change succeeds. The scheduled jobs are idempotent: the monthly reports and each month's subscriptions can run again, or catch up after the server was off, without creating duplicates. 800+ automated checks in 58 suites, and GitHub Actions builds and unit-tests every push.
Built with C#, ASP.NET Core, React, TypeScript, SQL ServerRead the case study
Hospital Information System
Offered to hospitals
A full stack system for a 100-bed general hospital: a React client over an ASP.NET Core API and SQL Server, with 260 API endpoints, 13 scope-aware roles and 212 automated tests wired into a GitHub Actions pipeline, 155 of them integration tests against a real SQL Server. Fifteen modules take a patient from the emergency room to the final bill.
My role: built alone, from requirements to tests. I'm now offering the system to hospitals.
How it's built
React → ASP.NET Core API → EF Core and stored procedures → SQL Server
JWT with server-side sessions and two-factor sign-in, EF Core for the model and transactional writes, versioned stored procedures for searches. Nurses and doctors each get their own home screen: the tasks of the shift, or the results and patients that need them.
Modules
Identity and access
Patients and encounters
Wards and medication
Clinical and NEWS2
Laboratory and radiology
Pharmacy
Perioperative care
Billing and payers
Inventory
Staffing
Role dashboards
Notifications
Reports
FHIR interface
System and health
Engineering details
Authorization combines permission and scope (hospital, department, work context, system) from effective-dated role assignments. Separation of duties stops a prescriber from approving their own prescription. Ward safety is built in: a medication schedule with overdue doses, NEWS2 early warning, a pre-op checklist that gates the case start, and an append-only audit trail enforced by a database trigger.
A team-built platform for the Ibad al-Rahman Association in Beirut: a bilingual Next.js frontend over a Spring Boot API and PostgreSQL. It manages people, a time-aware organisation tree, posts, access and approvals, across 54 screens in Arabic and English.
My role: a team project run in Scrum. I'm one of the frontend developers: I was the main contributor to the first version of the interface and its Arabic and English layouts, and I ran the screen-by-screen fix pass across all 15 epics. The backend team owns the API, and a QA team tests every story.
How it's built
Next.js → Spring Boot API → PostgreSQL
Next.js 16 and React 19 with TypeScript, Tailwind and shadcn/ui, next-intl for Arabic (right to left, the default) and English, TanStack Query, and forms validated with React Hook Form and Zod. The browser reaches the API through a same-origin proxy, so the refresh cookie stays first-party and the access token lives only in memory. By design, effective-dated data lets you view the organisation at any date, and sessions are server-side so they can be revoked at once.
Built so far
Identity and 2FA
Accounts and sessions
Organisation tree
People registry
Posts and reporting lines
Roles and access review
Operations and approvals
Audit and notifications
Metrics and reports
Coming next
Attendance
Treasury and payments
Phone and tablet QA pass
How the team works: Scrum
The work is planned as epics and user stories on a shared board, each story with its acceptance criteria. I take a story from the board, build it on its own branch, and open a pull request; QA then tests it against the acceptance map before the story is accepted, epic by epic. Fifteen epics so far, from sign-in and accounts to structure, positions, access, approvals, audit and the secretariat.
CI/CD with GitHub Actions
The team ships through GitHub Actions. In the backend repository, every push and pull request to main runs the tests against a real PostgreSQL started by Testcontainers. In the frontend repository, every push to the dev branch builds a Docker image and ships it to the dev server over SSH, with a key that can only deploy and report status. QA gets each build by promotion from dev, so what QA tests is exactly what ran on dev.
Access model
One person can hold several posts, and each post maps to roles. Access is computed per person and per date as permission-and-scope pairs, deny by default, with row filters and field visibility (hidden, masked, read-only, editable). Roles are versioned, and requests go live once the approvers resolved from the reporting lines accept them.
Built with Java 21, Spring Boot, PostgreSQL, Next.js
UI/UX projects
My featured UI/UX projects, from fintech and healthcare to e-commerce and food ordering. Each one opens as a live site you can click through and use.
Fintech · Website and app
PayWallet
A money-transfer app and its website. The phone on the page is the working app: send money, freeze the card, watch your spending update.
A clinic's day on one screen: the waiting room with live wait times, each patient's file and progress, prescriptions, booking and an end-of-day summary.
The same six steps, from first conversation to production.
Understand
Learn the business rules, the requirements and what users actually need before writing code.
Design
Plan the relational schema, the API contracts and where each service boundary sits.
Build
Build the backend logic, API and interface, keeping business rules and data access clearly separated.
Debug
Test error handling, security policies, edge cases and data validation.
Refactor
Clean up the code, tune the queries and keep the patterns consistent.
Deploy
Configure production, the proxy server and a reliable release process.
The engineering values behind every project above, each where it is real:
Least privilege
The school's API login can only run stored procedures. The hospital's runtime login has no DELETE, no schema changes and no updates on append-only tables.
Idempotent by design
A job that runs twice does no harm. The school's monthly reports and subscription months catch up after downtime without duplicates.
Cache with a clear end
The school caches read-only answers per person for seconds, and the first successful change throws every cached answer away.
One rule, one place
Rules live in one service or procedure, never in the screens. The 72-hour edit window is enforced inside the stored procedure.
Tests in the pipeline, shipped by pipeline
The hospital's GitHub Actions pipeline is set up to run its 212 tests, 155 of them integration tests against a real SQL Server. The Tarbawi team deploys every push to dev automatically.
A record nobody can edit
Sign-ins, clinical and financial changes and permission refusals are audited, and a database trigger keeps the hospital's audit trail append-only.
Where I've worked
Nurse first, then designer, now developer. Each role taught me something the next one needed.
– now
Full-stack software developer
961 Developments
I build systems for schools and healthcare teams, from the database schema to the interface, with C#, ASP.NET Core, SQL Server and React, and take each one from the first idea to launch.
– now
Frontend developer
Tarbawi Platform, a team project
A Scrum team with backend developers and QA. Each story gets its own branch and pull request, and QA accepts it against the acceptance map. I was the main contributor to the first version of the interface.
–
UI/UX designer
10+ product design projects across healthcare, fintech, e-commerce and food delivery: user flows, wireframes, prototypes and reusable design systems. See the UI/UX projects.
–
Nursing
BSc in Nursing from Makassed University of Beirut. Hands-on experience with clinical workflows, high-responsibility environments and people who need things to work under pressure.
BSc in Nursing
Makassed University of Beirut, 2025. GPA 3.63/4.0, with distinction.
Software engineering
Ongoing, mentored by working engineers: C# backends, database design, APIs, testing and deployment.
Volunteering
Three years as general secretary and operations manager of a public association, coordinating volunteers and students.
