/ capabilities

Good software needs the whole picture.

I work across product engineering, delivery, and security—building useful interfaces, connecting the systems behind them, and thinking about what happens after launch.

Product engineering·Systems & delivery·Secure engineering
12high-priority issues identified during an internship assessment
30+source files in a production B2B platform built from scratch
2languages supported in the Samaale platform
4protected server workflows in this portfolio platform
01 / how I work

Three connected disciplines.

My strongest work happens where product quality, reliable delivery, and security meet.

01

Product engineering

I build interfaces and application flows that make a product easy to understand and use, then connect them to the services behind them.

  • React 19 and TypeScript application development
  • Responsive interfaces and reusable component systems
  • API integrations, authentication, and data flows
Tools I use
02

Systems & delivery

I work across the code and the path it takes to production: automation, Linux operations, source control, and deployment.

  • Python utilities and repeatable automation
  • Linux administration, shell scripting, and C programming foundations
  • Repository workflows and cloud deployment
Tools I use
03

Secure engineering

Security is part of how I approach software: understand the attack surface, validate risk in authorized settings, and make the next fix clear.

  • Application and network vulnerability assessment
  • Web request inspection and controlled exploit validation
  • Risk prioritization and developer-focused documentation
Tools I use
02 / toolkit

Tools behind the work.

Select a tool to see how it fits into my work and the projects where it appears.

03 / foundations

Built on fundamentals.

Coursework that supports the way I reason about software, systems, and security.

01Software EngineeringIn-depth study of software life cycles, focusing on agile methodologies and robust architectural patterns.

ChallengeCoordinating complex design work with shifting requirements and team deadlines made this course feel like a real-world engineering sprint.

Key takeaways
  • Mastered SDLC phases from requirements gathering to maintenance.
  • Implemented agile workflows in collaborative development environments.
  • Applied advanced design patterns to solve complex software engineering problems.
02Linear AlgebraFoundational mathematics for advanced computing, covering vector spaces and matrix operations.

ChallengeVisualizing high-dimensional spaces and applying abstract algebraic concepts to real code problems was the hardest part.

Key takeaways
  • Understood vector spaces and linear transformations for data modeling.
  • Applied matrix operations in machine learning and cryptographic algorithms.
  • Developed mathematical intuition for high-dimensional data analysis.
03PythonAdvanced Python programming with a focus on automation and security-oriented scripting.

ChallengeBalancing rapid scripting with secure dependency management and safe system access was the most challenging part.

Key takeaways
  • Analyzed complex data structures for efficient information processing.
  • Developed automated security scripts using libraries like Scapy and Sockets.
  • Built robust backend systems with security-first coding practices.
04C ProgrammingLow-level systems programming emphasizing memory management and secure software development.

ChallengeManaging raw pointers, manual memory allocation, and debugging subtle buffer issues made this course particularly intense.

Key takeaways
  • Mastered pointer manipulation and manual memory management techniques.
  • Identified and mitigated common overflow vulnerabilities at the system level.
  • Built performance-critical applications with minimal overhead.
05Information SecurityComprehensive coverage of the CIA triad, network security, and modern risk assessment frameworks.

ChallengeTranslating theoretical threat models into practical defensive strategies and breach simulations was the toughest step.

Key takeaways
  • Implemented security protocols based on Confidentiality, Integrity, and Availability.
  • Performed detailed risk assessments using industry-standard frameworks.
  • Explored cryptographic systems and their applications in data protection.
06TypeScriptAdvanced type-level programming for building scalable and maintainable web applications.

ChallengeDesigning types for a dynamic codebase while avoiding overcomplication was the trickiest part.

Key takeaways
  • Utilized type safety and generics to eliminate runtime errors.
  • Implemented complex interfaces for seamless API data modeling.
  • Integrated TypeScript with modern frameworks like React for enterprise-scale UI.
07ReactModern component-based UI development with a focus on performance and state management.

ChallengeKeeping complex state predictable while preserving responsiveness across the interface was the hardest part.

Key takeaways
  • Built scalable SPAs using advanced React Hooks and custom state logic.
  • Optimized rendering performance using memoization and code-splitting.
  • Developed complex routing systems for seamless user navigation.
08JavaObject-oriented programming and enterprise application development using the Java Ecosystem.

ChallengeMastering concurrency and JVM internals while keeping code secure in multi-threaded contexts was the greatest challenge.

Key takeaways
  • Designed reusable software architectures using OOP principles and JVM internals.
  • Implemented multithreaded systems for concurrent data processing.
  • Applied secure coding standards to prevent injection and session vulnerabilities.
09JavaScriptPro-level JavaScript covering ES6+, asynchronous programming, and DOM architecture.

ChallengeManaging async flow and browser compatibility while keeping interactions smooth was the most difficult part.

Key takeaways
  • Mastered async/await and promises for handling complex asynchronous operations.
  • Utilized closures and lexical scoping for modular code design.
  • Built interactive web experiences through efficient DOM and Fetch API usage.