by Nathan J Harris
June 5, 2025
CSPB 3112 Professional Development

Overview

With a background in film and video production and a passion for building software tools for small businesses, I connected with a friend of mine who owns a video production company and decided to build a project management application focused on managing video projects with clients and collaborators.

Vision Statement

This project for my Professional Development course will serve as the foundation to launch a full stack application with a real client and a real world use case. It will unfold in three overlapping modules.

Module 1 Planning and Design

This module of the project includes the creation of detailed planning documentation in close collaboration with the client to ensure that the project is useful and aligned with their business needs. Deliverables will include:

  • User Stories
  • Feature List
  • Entity Relationship Diagram (ERD)
  • Mock ups / Wireframes
  • API Route Specifications
  • Deployment Plan
  • Testing Strategy
  • ReadMe / Project Overview The objective is to produce documentation that could be handed off to any full stack developer or team and allow them to build the project with minimal clarification. Much of this documentation has already been drafted prior to the start of the course.

    Module 1 Professional Growth:

    This phase will deepen my skills in client collaboration, requirements gathering, technical documentation, and early-stage software design — all essential for freelance and team-based professional work.

    Module 2: Backend Skills Development

    This phase focuses on learning C# and ASP.NET Core Web API, a professional enterprise backend stack. I will follow tutorials from Microsoft’s official documentation and supplementary sources to build foundational skills including:

  • C# fundamentals for .NET development
  • User authentication and role-based access control
  • CRUD operations with SQL Server
  • Unit and integration testing
  • Deployment using Docker and CI/CD pipelines
  • Structured logging and basic error monitoring
  • API documentation following RESTful conventions
  • Professional code organization and version control practices

    Module 2 Professional Growth:

    This phase expands my backend development skills by introducing a new language (C#), a new framework (ASP.NET Core), and several industry-standard tools used in production environments. It also sets the groundwork for future client work in more enterprise-grade ecosystems.

    Module 3: API Implementation

    In this module, I will implement the backend API for the client-facing application using the technologies and patterns learned in Module 2. The API will include:

  • Secure user authentication with role-based access
  • CRUD functionality for one key entity (Projects)
  • Adherence to RESTful conventions
  • Fully tested and documented endpoints

    Module 3 Professional Growth:

    This phase integrates everything I’ve learned into a functioning deliverable for a real user.

    Bonus Module (Outside Course Scope)

    If time permits, I will build a frontend for the application using React and Material UI that matches the features in the API. If frontend development falls outside the course timeline, the approved wireframes and user workflows from module 1 will fully explain how the API is meant to be used.

    Motivation

    This project is important to me because it sits at the intersection of what I want to build and how I want to grow as a developer. It gives me the opportunity to create a real software tool for a small business while expanding my technical skillset in a focused and meaningful way.

What originally drew me to software engineering was the idea of building practical, custom tools that help small businesses thrive. This project brings that goal to life. By designing and delivering a solution for a real client — someone I know and whose business needs I understand — I’m taking a tangible step toward launching myself as a software developer with a focus in serving small businesses.

While I have a foundation in full stack development from a previous coding bootcamp, there are specific professional and enterprise-level technologies I haven’t yet explored deeply. This project is my opportunity to close those gaps, learn robust tools used in industry, and solidify the skills needed to build scalable, maintainable, and production-ready applications.

Specific Measurable Goals (Learning Objectives)

  • Finalize core project planning materials, including user stories, ERD, API routes, and wireframes
  • Gain working knowledge of C# and ASP.NET Core by applying concepts from official tutorials to build the project’s backend
  • Implement user authentication and CRUD operations for one core entity (Projects) using a relational database
  • Write tests for key backend logic
  • Deploy the backend using Docker and CI/CD tools
  • Document the API and maintain a well-organized GitHub repository with clear version control practices

    Risks to Project Completion

    1. New language and framework:

    I am using C# and ASP.NET Core for the first time in a production-style project. While I have experience with other languages and frameworks, learning and applying enterprise-grade tools in a short timeframe presents a challenge.

    2. Limited project hours:

    The course allocates only 3–4 hours per week to the project, which includes blogging and piazza participation. This time constraint requires careful planning and scope management.

    3. Integration complexity:

    Coordinating authentication, database integration, testing, deployment, and documentation into a cohesive backend API may be more complex than anticipated within the course schedule.

    4. Optional frontend work:

    Building a frontend in React is not required for this project but is a potential stretch goal. If not carefully managed, this could compete for time with more critical backend objectives.

    Mitigation Strategies

    1. Structured tutorials and phased implementation:

    I will follow well-structured, goal-oriented tutorials from Microsoft and other trusted sources, and apply new concepts incrementally through the project’s phases.

    2. Dedicated learning time outside course hours:

    I am allocating an additional 9 hours per week outside the course to support the depth of learning and implementation required.

    3. Minimum Viable Scope (MVP):

    I have intentionally limited the project to one or two core features (user authentication and minimal project tracking) to ensure successful delivery within time constraints.

    4. Frontend as bonus only:

    The frontend portion is clearly scoped as a bonus objective. If time allows, I will begin development using React and Material UI. Otherwise, wireframes and API documentation will clearly demonstrate how the backend is intended to be used.

    Project Assessments

  • Project Planning documentation complete and client reviewed
  • Backend API Meets functional requirements
  • Tests verify core functionality
  • Successful Deployment and Containerization
  • Clear, professional project documentation

    nathanjh-28.github.io/vp-suite-blog

    Fallback Weekly Schedule

    As I progress through the learning materials for C# and .NET, if I am at a loss on what to do next, this schedule will help minimize my time making decisions by providing learning material to fallback on. I asked chat gpt to help me based on my proposal.  I find that building out a schedule is really hard when you are just getting to know the jargon associated with your learning objectives. Not sure if this is a good schedule but it is subject to change every week.

    Week 1: C# Fundamentals

  • Key Topics: Variables, Data Types, Control Structures, Methods, Classes, Error Handling
  • Why: Establish a strong foundation in C#, the primary language for .NET development.
  • Practice: Build a simple console application (e.g., a calculator or to-do list).
  • Resources:
  • C# Fundamentals for Absolute Beginners – Microsoft Learn
  • C# Tutorial – W3Schools

    Week 2: ASP.NET Core Basics

  • Key Topics: .NET CLI, Project Structure, Dependency Injection, Configuration Files
  • Why: Understand the structure and components of an ASP.NET Core application.
  • Practice: Scaffold a new Web API project and explore its components.
  • Resources:
  • Tutorial: Create a controller-based web API with ASP.NET Core

    Week 3: CRUD Operations with Entity Framework Core

  • Key Topics: DbContext, Migrations, Entity Models, LINQ
  • Why: Learn to interact with databases using Entity Framework Core.
  • Practice: Implement CRUD operations for a sample entity (e.g., Product).
  • Resources:
  • Tutorial: Implement CRUD Functionality - ASP.NET MVC with EF Core

    Week 4: RESTful API Design and Documentation

  • Key Topics: REST Principles, Routing, Swagger/OpenAPI
  • Why: Design APIs that are intuitive and well-documented for consumers.
  • Practice: Add Swagger to your API and test endpoints.
  • Resources:
  • ASP.NET Core web API documentation with Swagger / OpenAPI

    Week 5: Authentication and Authorization

  • Key Topics: ASP.NET Core Identity, JWT, Role-Based Access Control
  • Why: Secure your API by implementing authentication and authorization mechanisms.
  • Practice: Implement user registration, login, and role-based access control.
  • Resources:
  • Role-based authorization in ASP.NET Core

    Week 6: Input Validation and Error Handling

  • Key Topics: Data Annotations, Model Validation, Exception Handling
  • Why: Ensure data integrity and provide meaningful error messages.
  • Practice: Validate user inputs and implement global exception handling.
  • Resources:
  • Model validation in ASP.NET Core MVC

    Week 7: Unit and Integration Testing

  • Key Topics: xUnit, Moq, TestServer
  • Why: Write tests to ensure your application behaves as expected.
  • Practice: Write unit tests for your services and integration tests for your controllers.

  • Resources:

  • Testing ASP.NET Core services and web apps

    Week 8: Logging and Monitoring

  • Key Topics: Built-in Logging, Serilog, Application Insights
  • Why: Monitor application behavior and diagnose issues effectively.
  • Practice: Implement structured logging and set up monitoring tools.

  • Resources:

  • Logging in .NET Core and ASP.NET Core

    Week 9: Docker and Deployment

  • Key Topics: Dockerfile, Docker Compose, Deployment Strategies
  • Why: Containerize your application for consistent deployment across environments.
  • Practice: Create a Docker image of your application and deploy it.
  • Resources:
  • Run an ASP.NET Core app in Docker containers

Week 10: Code Organization and Version Control

  • Key Topics: Clean Architecture, Git, CI/CD Pipelines
  • Why: Maintain a scalable and maintainable codebase with proper version control.
  • Practice: Refactor your codebase following clean architecture principles and set up a CI/CD pipeline.

  • Resources:

  • Clean Architecture in ASP.NET Core