Alexander Flood | CS-499 ePortfolio

This portfolio represents my progression from building small course projects to implementing secure, scalable, and maintainable systems that reflect industry practices. Throughout the program, I strengthened core competencies across software design, algorithms & data structures, databases, security, and communication.

Collaboration & Communication

Throughout each enhancement, I worked with the same care and structure used in professional projects. I documented design decisions in detailed Microsoft Word documents, wrote clear inline comments, and prepared my code for review and feedback. I tailored explanations for different audiences by writing several README files, technical notes for developers, and concise narratives and reflection journals for non-technical readers.

I also focused on process transparency and maintainability. I used meaningful commit messages, organized repository structure and issue notes, and included setup instructions so others could reproduce results quickly. I incorporated instructor feedback into revisions, clarified UI where needed, and kept documentation synchronized with my changes to make sure the rationale behind my choices remained were easy to understand.

Software Engineering

I used engineering best practices throughout my work, using Docker Compose to containerize services and maintain a clear separation between the application, database, and authentication layers. This modular architecture simplified deployment, made local testing more predictable, and mirrored production-like environments you find on professional teams. I also adopted an API-first mindset, designing endpoints and data models before implementing user interfaces to ensure consistency across systems. On the Android side, I reinforced clean architecture principles by separating UI, networking, and persistence logic into distinct layers.

To enhance reliability, I implemented health checks, error handling, and liveness endpoints that improved observability across services. These changes not only made the application more fault-tolerant but also helped streamline debugging and performance monitoring. The result is a project that demonstrates modern full-stack practices while remaining easy to extend and maintain.

Data Structures & Algorithms.

I designed efficient data-driven features that analyze and interpret time-series weight data. The enhancements include a seven-entry rolling average to smooth out short-term fluctuations and an ordinary least squares regression to calculate a trend line and projected goal-achievement date. Each algorithm runs in predictable O(n) time and was implemented with clear preconditions and edge-case handling to prevent misleading outputs.

In addition to algorithmic accuracy, I focused on readability and maintainability. I documented mathematical logic with concise inline comments and structured methods so future developers could easily extend the analytics layer with additional computations. These improvements reflect my ability to integrate algorithmic reasoning into practical, user-facing applications.

Databases

I implemented an offline-first data model that synchronizes a local SQLite cache with a cloud-hosted MySQL database via RESTful API. The app retrieves cached data instantly for responsiveness, then performs background synchronization to maintain accuracy and consistency. This design balances performance and reliability while allowing users to continue tracking data even without connectivity.

I also focused on schema alignment between local and remote databases to avoid conflicts during synchronization, ensuring timestamp and ID integrity across both systems. These improvements demonstrate practical skills in database normalization, API integration, and data reliability, creating a seamless bridge between client storage and cloud persistence.

Security Mindset

I used standards-based authentication (Keycloak + OpenID Connect), validated JWTs server-side, and encrypted tokens at rest on Android using the Android Keystore. This aligns with Zero Trust principles by verifying every request and scoping data per user. I also implemented HTTPS for all network communication and enforced secure token lifecycles to prevent replay attacks. Together, these measures ensure data confidentiality and integrity while maintaining a seamless user experience.

Overall, these artifacts demonstrate my readiness to contribute to full-stack or mobile teams focused on cloud-based deployments, security, and user-friendly software. Through this work, I met the key CS-499 outcomes by designing secure, scalable systems (Outcome 4), applying algorithmic principles to real-world problems (Outcome 3), and maintaining a security-first approach in architecture and implementation (Outcome 5). Together, these experiences reflect technical depth and professional growth across the multiple areas of computer science.

I began this project by conducting an informal code review to assess the current architecture, identify risks, and prioritize my enhancements. The review focused on structure and readability, API design, security concerns (authentication and token handling), and database schema alignment. This gave me a concrete roadmap for the three enhancements I made and ensured each one mapped to a course outcome.

The screencast below walks through the existing functionality, targeted improvements, and the plan for each enhancement with clear alignment to the course outcomes.

Watch the Code Review Video

GitHub Repository (all artifacts & narratives):
https://github.com/daftpy/CS-499