Skills in Action
A technical showcase mapping real world artifacts to core engineering competencies in backend development and DevOps.
Container Orchestration
Dockerfile Design
In my professional work, our team needed to update development Dockerfiles because some base images were reaching the end of their lifecycle and creating security concerns. Outdated base images can introduce vulnerabilities and create compatibility issues during builds or deployments. I helped review and update Dockerfile configurations, checked how dependencies were installed, and considered how a base image change could affect the application during build and runtime. This work connects to container orchestration because Dockerfiles define how applications are packaged into containers and help ensure services can run consistently across environments.
Helm Chart Authoring
Backend services in a Kubernetes environment depend on accurate deployment configuration to receive the correct environment variables and connect properly with other systems. Missing or incorrect configuration values can cause deployment failures or broken service behavior. I worked with Helm chart configurations to support Kubernetes deployment changes, including updates related to pod environment variables and service settings. This required me to understand how Helm charts define Kubernetes resources and how application settings are passed into running containers. This work demonstrates container orchestration because Helm supports repeatable, environment-specific deployments and connects application configuration with infrastructure reliability.
Kubernetes Course Environment
To strengthen my DevOps and infrastructure engineering skills, I needed hands-on practice with Kubernetes beyond simply reading about it. I worked through a Kubernetes course repository where I practiced using Kubernetes resources and learned how containerized applications are deployed, exposed, updated, and managed inside a cluster. Through this work, I gained exposure to concepts such as pods, deployments, services, configuration, and cluster behavior. This experience supports my container orchestration skill by showing that I can connect Kubernetes theory to practical deployment workflows used in modern infrastructure environments.
API Development
Budget Server API
I created the Budget Server to support a command-line budgeting application that needed structured server-side logic, persistent storage, and maintainable backend organization. I designed and worked with RESTful API endpoints, organized backend routes and handlers, connected the server to storage, and supported budgeting features for the client application. This required me to think through request handling, response structure, validation, authentication, and how data moved between the client, server, and database. The project reflects my API development skill because it shows my ability to build practical backend services that support real user workflows and maintain clean data flow across an application.
Skribbl.io Clone
A Skribbl.io style drawing game requires backend logic that can support live user interaction, shared game state, and communication between multiple clients. In this project, I worked on backend behavior that allowed users to join, interact, and participate in a shared game experience. This required me to think about client-server communication, application state, event handling, and how the backend supports multiple users at the same time. The project connects to API development because it shows my ability to support real-time application behavior, not just basic request and response features.
C++ Chat Room
I wanted to strengthen my understanding of how users connect, exchange messages, and communicate through server side logic, so I worked on a C++ chat room application. This project required me to think about sessions, message flow, network communication, and how connected users interact through the backend. Building this in C++ also helped me understand communication patterns at a deeper level than I would in a higher level framework. This artifact supports my API development skill because chat applications rely on clear client-server communication and real-time backend design.
Software Integration
Budget Server + Plaid
A budgeting application is more useful when it can work with real banking data instead of relying only on manually entered information. To support this, I integrated the Budget Server with the Plaid API so the application could access banking and transaction data. This required me to work with API credentials, request and response formats, data mapping, backend processing, and how external financial data should flow into the application’s budgeting features. This project demonstrates software integration because it connects an external financial data provider with my own backend application to create a more practical and functional system.
Internship Integrations
In my internship and professional work, backend services often needed to communicate with systems that supported business operations such as inventory, orders, pricing, and customer information. I worked with SQL queries, API requests, environment variables, authentication requirements, and ERP related integrations. This required me to understand how data moved between systems, how one service’s output became another system’s input, and how integration issues could affect business workflows. This experience connects directly to software integration because it shows my ability to work with databases, APIs, and business systems in a real professional environment.
CLI & Server Integrations
The Budget CLI acted as the user facing command-line tool, while the Budget Server handled backend logic, storage, and application processing. These two components needed to communicate clearly so the user could perform budgeting actions through the CLI and receive useful responses from the server. I designed how CLI commands would translate into server requests and considered how server responses, returned data, and errors would be displayed back to the user. This work reflects software integration because it shows my ability to connect independent software components through clean client-server communication.