Building Real Backend Logic at Full Sail University

This post covers my experience with Programming for Web Applications, a course that shifted my focus from frontend logic into real backend development. This was the point where I learned how to build APIs from scratch, document them properly, write unit tests, and structure backend code in ways that scale. It was a major step toward understanding how full systems work together. Below is a breakdown of each week and how it contributed to my growth as a developer.

---

Week 1: Creating an API and Working With Middleware

My thoughts at the time

Week one felt like diving into the deep end of backend development. Creating my first API endpoint made everything feel more real. Up until now, my code mainly lived in the browser, but suddenly I was building something that could power other applications. Working with middleware also introduced a new layer of structure. It forced me to think about how requests travel through the system and how logic can be separated into clear, reusable pieces.

Regular expressions were another big part of the week. They felt cryptic at first, but once I learned how they work, I started appreciating how powerful they are for validation and pattern matching.

Retrospective insight

This week made me much more aware of how backend systems process data. Creating an API endpoint from scratch gave me confidence in building server-side features. Understanding middleware helped me think more modularly, and regex introduced me to a tool I still rely on for validation. Looking back, these concepts built the foundation for almost every backend or full stack project I have worked on since.

---

Week 2: Technical Documentation and Writing Clearly for Developers

My thoughts at the time

Week two shifted focus toward documenting APIs and writing clear instructions for other developers. At first, writing documentation felt tedious, but I quickly realized how essential it is. Good documentation removes confusion, reduces mistakes, and helps others use what you have built without guesswork.

Learning how to describe routes, parameters, responses, and error cases made me more aware of how to communicate through my code. It was also surprisingly helpful for improving my own understanding of the system.

Retrospective insight

This week made me appreciate documentation as a critical part of development. Even when I build things only for myself, writing clear notes and route descriptions helps future me understand decisions I made earlier. The ability to document APIs has continued to be valuable in collaborative projects and internship work, where clarity matters as much as functionality.

---

Week 3: Unit Testing and Building Confidence in Code

My thoughts at the time

Week three introduced unit testing, which was a completely different mindset from writing features. Instead of building functionality, I was testing it. Learning how to write tests, assert expectations, and validate that my APIs behaved correctly gave me a new level of control over my code.

Publishing tests as an npm module felt challenging but also empowering. It made the work feel more official, like I was contributing something structured that could be reused in another project.

Retrospective insight

Learning unit testing early made me a more careful and confident developer. It taught me not to assume my code works simply because it runs once. Testing became a way to ensure reliability and catch problems before they affect users. Even when I do not write formal tests today, the mindset of verifying behavior and thinking through edge cases has stayed with me.

---

Week 4: Modular Design and Publishing to npm

My thoughts at the time

The final week was focused on modular design and packaging code for reuse. Turning logic into an npm module made the entire development process feel more professional. It required thinking about how the code should be structured, how others might use it, and how to make the interface clean and logical.

Publishing the module was both exciting and intimidating. It was the first time something I wrote existed outside a classroom environment and could be installed like any other library.

Retrospective insight

This week taught me the value of reusable architecture and clean module design. Modern development depends heavily on small, focused packages that work together. Understanding how to publish, version, and maintain a module helped me grasp how open source ecosystems function. It also gave me confidence that I could build things meant for real-world use, not just classroom assignments.

---

Closing Thoughts

Programming for Web Applications was one of the most transformative backend courses in the program. It introduced concepts that helped me understand not just how to write features, but how to structure, test, and document them in a way that scales. Learning how APIs, modules, tests, and documentation fit together prepared me for full stack development and shaped how I think about building reliable systems. This course marked a major step toward feeling like a capable and well-rounded developer.