Lukas Brkovic Leighton

Professional Self-Assessment

I am completing the Bachelor of Science in Computer Science at Southern New Hampshire University, and this portfolio is the record of what I can build. Alongside my studies, I work as an AI rater with TELUS Digital, evaluating the response quality of a production AI search system for a major technology company; the work consists of judging relevance, quality, and guideline compliance, response by response, against detailed written standards. I have also designed, built, and operated multiplayer online games since childhood, and I maintain an active player base today on AetherSeed, a three-dimensional multiplayer game I run with an AI-driven content pipeline. My goal is to work in AI and machine learning engineering and to pursue a master's degree in artificial intelligence. Completing this program sharpened that direction. The coursework gave me breadth across software engineering, algorithms, databases, and security, and the capstone required me to integrate all of it into one production-quality system. The sections below introduce the skills I bring to a team; the enhanced artifact that follows this self-assessment provides the evidence.

Collaborating in a Team Environment

My clearest collaboration training comes from working inside a large, distributed team. At TELUS Digital, I work within a community of raters spread across many countries who must produce consistent judgments without ever meeting. Consistency is achieved through shared written guidelines, calibration exercises, and disciplined attention to updates, and contributing well in that structure is a daily exercise in aligning my work with a team standard rather than a personal one. At SNHU, every course included structured peer discussion in which I presented work in progress, critiqued the work of classmates, and revised my own based on their responses. In the capstone, I practiced collaboration in the form a professional team depends on most: documentation. I wrote developer-facing README files and contextual in-code comments for the next person who touches the code, recorded a code review video addressed to a reviewing audience of peers, and added closed captions to that video so it also serves viewers who are deaf, hard of hearing, or working in a second language.

Communicating With Stakeholders

Running live games has meant answering to the most demanding stakeholders I know: players. For years I have announced changes, explained decisions in plain language, gathered feedback, and shipped corrections when the feedback was right. Formal coursework built the professional register on top of that experience. In CS-340, I built the Grazioso Salvare dashboard for a specified client, translating the company's written business rules — filters for water, mountain, and disaster rescue dogs — into an interactive tool a non-programmer can operate. Across the capstone I produced a milestone narrative for each enhancement, written for an instructor and technical reviewers, and a code review video pitched to peers and a manager. I adjust the form of communication to the audience: prose for reviewers, a walkthrough for colleagues, plain language for users.

Data Structures and Algorithms

I choose data structures by measured trade-off, not by habit. In CS-300, I built a course-planning tool in C++ after comparing vectors, hash tables, and binary search trees on runtime and memory cost with Big-O analysis, then implemented the planner on a balanced binary search tree so course listings emerged already sorted. In CS-370, I implemented a deep Q-learning training algorithm for a maze-navigation agent: a neural network with experience replay and target values, epsilon-greedy exploration restricted to valid actions, and a training loop with two convergence criteria, which reached a one hundred percent completion rate from every free starting cell. Those projects, both outside this portfolio's artifact, show the same habit the capstone deepened — justify the structure, measure the cost, and prove the result with tests.

Software Engineering and Databases

My engineering foundation is full-stack. In CS-465, I built a complete MEAN-stack travel application — the same application this portfolio enhances — with a customer site, an administrative single-page application, and a JWT-secured REST API. In CS-340, I paired MongoDB with a reusable, documented Python CRUD module and a dashboard under the model-view-controller pattern. CS-320 built my testing discipline: I delivered three Java backend services with complete JUnit 5 test suites covering positive, negative, boundary, and exception cases, reaching one hundred percent line and branch coverage on the key classes (JUnit User Guide, n.d.). Outside coursework, AetherSeed is engineering at production scale: a TypeScript monorepo with schemas shared between client and server, an authoritative game server, and strict validation that accepts AI-generated content only as checked data, never as code. I am currently completing CS-360 alongside the capstone, building an Android inventory application in Java.

Security

I treat security as a starting assumption rather than a final step. In CS-305, I assessed and hardened a financial consulting application: I ran dependency vulnerability scans with OWASP Dependency-Check, added SHA-256 checksum verification for data integrity, and configured HTTPS so traffic moved encrypted. The working habits that project built — dependencies are attack surface, integrity is verified rather than assumed, transport is encrypted — have followed me since, and I use the community standards published by the OWASP Foundation (2025) as working checklists rather than reading material. In CS-465, I implemented JWT authentication with tests proving that unauthenticated requests are refused. Operating internet-facing game servers adds a practical education no classroom provides: real, unsolicited adversarial traffic, which is why my servers validate everything and trust nothing a client sends.

How My Artifacts Fit Together

I chose to enhance a single artifact — Travlr Getaways, the full-stack travel application from CS-465 — in all three categories, because depth on one codebase shows something a scatter of small samples cannot: the ability to carry one system from front end to database at a professional standard. Enhancement One, in software design and engineering, replaced the Angular administrative application with a React 18 front end in strict TypeScript, consolidated duplicated forms into one shared, metadata-driven component, repaired the JWT middleware, and closed a stored cross-site scripting vector with a regression test that proves it stays closed. Enhancement Two, in algorithms and data structures, moved searching, sorting, and pagination to purpose-built server-side implementations: a stable merge sort, a bounded min-heap that selects the top results in O(n log k) time rather than sorting everything in O(n log n), field-weighted relevance scoring, and validated cursor pagination. Enhancement Three, in databases, pushed the work into the data layer itself: Mongoose schema validation, a weighted text index, an aggregation pipeline that executes search and statistics inside MongoDB (MongoDB, Inc., n.d.), a parity test proving the database engine and the application engine return identical orderings, role-based access control, and sanitization middleware that strips NoSQL injection operators. After all three enhancements were graded, I kept improving for the final portfolio: a setup script that brings the whole application up with two commands, a completed customer site with a working, database-stored contact form, and trie-backed search suggestions with a documented O(prefix) lookup. I also added price and rating filters executed inside the aggregation pipeline, with the parity test extended to prove both engines still agree, and a community trip-rating feature whose averages are computed inside the database, with one enforced rating per account per trip. Finally I deployed the finished application to a public server over HTTPS — the database reachable only from the machine itself, the backend supervised so it restarts if it stops, and certificates obtained and renewed automatically — and documented the whole setup so another developer can reproduce it.

Together the three enhancements trace one path — an authenticated query traveling from the React front end, through sanitization middleware and the algorithm layer, down to the database indexes — and the portfolio presents that path directly: an architecture diagram, a narrative for each enhancement, the code review video where the plan began, and the original and enhanced code side by side. Collectively, this work demonstrates the five outcomes of the Computer Science program: collaborating around a shared codebase, communicating to distinct audiences, solving problems with justified algorithmic trade-offs, applying professional tools and techniques, and designing with a security mindset. The sections that follow show the work itself.

References