Projects Portfolio

Job boards list thousands of US openings that are mostly irrelevant or duplicated, so manual review was slow and inconsistent. The application needed to gather listings continuously, decide which ones actually matched the target roles, and keep the results queryable instead of leaving them buried in raw HTML.

I designed and built the whole pipeline end to end: the scraping layer with rate-limit handling and retry logic, the NLP filtering and classification step, the SQL Server schema and stored procedures, and the repeatable run pipeline that ties collection, processing and persistence together.

Written in C# on .NET, the scraper walks job listing pages politely with rate-limit handling, normalises each posting into a common record, and runs the collected text through an NLP pass that scores and classifies postings by relevance. Only classified results are written to SQL Server, with the schema designed so new fields or categories can be added without breaking existing queries.

Vessel operators were relying on disconnected sources: live device telemetry arrived on its own, maintenance records lived in spreadsheets, and nobody had one place to answer "where is the vessel and is it fit to run". The application was built to consolidate vessel location, performance and maintenance state into a single operational view for the crew.

I built the data model and the dashboards, wired live device telemetry into DataMiner Cube, and surfaced the alarm and maintenance state that operators actually act on. The low-code configuration and connector setup were delivered alongside the C# and XML work needed to make the data land cleanly.

Developed as a low-code application on Skyline DataMiner, using DataMiner Cube as the runtime and a CATA catalog to describe the vessel devices. I modelled the vessel and maintenance entities, connected the telemetry sources into Cube, then built the dashboards and alarm configuration on top so the same data drives both the visual overview and the background maintenance tracking.

Hospitals need patient records, scheduling and staff workflows to line up with each other in real time. Without a single platform, appointment and patient updates are duplicated across systems and clinicians end up working from stale information, so the goal was one reliable source of truth for day-to-day hospital operations.

I owned the API design and the relational schema modelling for patients, appointments and staff, implemented the ASP.NET Core REST layer, and built the Vue.js front end with its dashboards so the interface stayed responsive while records changed underneath it.

The backend is ASP.NET Core with Entity Framework over SQL Server, exposing REST APIs for every entity so the front end never talks to the database directly. Schema design came first so the real-time update path stayed consistent, then the Vue.js SPA was built against those contracts, with patient status changes pushed through the API so the dashboard reflects them immediately.

Local producers in the Middle East had good product but no route to sell it online, while customers wanted the same convenient shopping experience they get from larger retailers. The store was built to give small Egyptian businesses a working online shop for bakery items, fresh produce and womenswear without needing a custom marketplace.

I delivered the full WordPress and Elementor Pro implementation: theme and page setup, the product catalog and category structure for bakery items, vegetables, fruit and clothing, the checkout and Google Payments configuration, and the responsive layout that makes the catalogue usable on phones.

Built on WordPress with Elementor Pro and an e-commerce plugin so the catalogue, cart and checkout are managed through a familiar admin area rather than custom code. Products were modelled with proper categories and attributes for fresh goods, payments were wired through Google Payments for local settlement, and the MySQL-backed store was tuned and tested for a smooth customer journey from listing to purchase.

Broadcast switchers were blind to the monitoring platform: their state lived inside the hardware and could not be tracked or controlled centrally. The connector was built to expose these physical devices to Cube so they could be monitored and driven like any other connected equipment.

I wrote the connector in C#, defined the device protocol in XML, mapped the switcher parameters onto the DataMiner data model, and implemented the polling and state-change handling that keeps the platform in sync with the hardware.

The protocol is declared in XML so the device contract stays readable and versionable outside the code, and the C# connector translates it into DataMiner parameters on start-up. I mapped each exposed signal to the data model, added the polling loop and change detection for live state, then verified the device could be monitored and controlled from within Cube.

City water networks were operated across scattered devices with no common picture of flow, pump status or distribution health. Operators needed one application to monitor the network in real time and act on anomalies before service is affected, backed by a database that keeps the history.

I built the low-code application on the DataMiner platform, configured the Cube services and CATA catalogs that drive it, implemented the monitoring of flow rates and pump and valve operations, and set up the alerting that flags anomalies in the distribution network.

Delivered as a low-code application using Skyline with DataMiner Cube handling the runtime and several connectors performing the different device tasks in parallel. The catalog definitions were written first so every device exposed a consistent parameter set, then the flows, pump and valve controls and the anomaly alerts were configured on top, with DataMiner database management providing the historical record for analysis.

Blackmagic Design switchers were only manageable from their own control panels, so broadcast equipment could not be discovered, monitored or driven from a central platform. The catalog was built to make these physical devices first-class citizens of the Skyline ecosystem so they could be controlled and observed like any other connected device.

I implemented the catalog on top of the Blackmagic Design SDK, handled device discovery and registration, wired real-time status monitoring and remote control through the SDK connector, and integrated it with the DataMiner ecosystem so the switchers could be managed from Skyline services.

The work was delivered as a Skyline catalog using the Blackmagic Design Switchers SDK, so the connector could be deployed on Skyline services and reused across environments. Device discovery and parameter definitions were handled first, then status polling and control actions were wired through the SDK, and the resulting connector was packaged and validated against the DataMiner ecosystem.