Vue 3 & Golang Full-Stack Real-Time Social Network + DevOps

Quick recap of the key concepts covered in this section before moving forward.

Setting up the essential tools required for backend and frontend development.

Installing Go and preparing the backend development environment.

Setting up Vue CLI to scaffold and manage the frontend application.

Exploring project resources and understanding the repository structure.

Creating the backend application and organizing a clean project structure.

Adding required dependencies to power the backend services.

Configuring and testing the database connection layer.

Integrating API documentation for better development and testing workflow.

Building the user registration endpoint with proper validation.

Generating JWT tokens for secure authentication.

Implementing login logic and returning authentication tokens.

Protecting routes using middleware-based authentication.

Fetching user details securely from the database.

Allowing users to update profile data safely.

Implementing follow/unfollow user relationships.

Building user suggestion logic based on system rules.

Handling secure account deletion operations.

Validating post data before saving to the database.

Retrieving a specific post with structured response handling.

Allowing post modifications with proper validation.

Implementing pagination for scalable post retrieval.

Adding search functionality for user posts.

Enabling users to comment on posts.

Handling secure post deletion operations.

Designing message models including unread tracking.

Creating the messaging endpoint between users.

Retrieving conversation messages efficiently.

Fetching unread messages for notification purposes.

Updating message status after reading.

Designing the notification data structure.

Implementing logic to generate notifications.

Resolving logic issues in retrieving user posts.

Creating endpoints to manage user notifications.

Understanding frontend architecture and project structure.

Connecting frontend API handlers to backend services.

Creating centralized state management for authentication.

Designing the authentication UI layout.

Implementing authentication logic inside the component.

Improving error handling in authentication flow.

Enhancing navigation and building the profile page.

Protecting routes based on authentication status.

Managing user state globally using store pattern.

Displaying user data dynamically in UI.

Connecting follow logic between frontend and backend.

Allowing profile updates from the frontend.

Handling POST requests for various features.

Managing post state inside application store.

Implementing post creation logic.

Designing the post creation UI.

Displaying paginated posts in the UI.

Handling post update and detail logic.

Rendering post content dynamically.

Implementing post editing functionality.

Displaying user-specific posts on profile page.

Building the sidebar UI component.

Resolving minor UI or logic issues.

Showing suggested friends dynamically.

Implementing search functionality in frontend.

Managing notification state in frontend.

Debugging and fixing frontend issues.

Building notification display UI.

Displaying notification counter badge.

Connecting chat-related API endpoints.

Managing chat state and conversations.

Integrating chat route into navigation.

Implementing chat logic and interactions.

Designing the chat user interface.

Debugging chat-related issues.

Displaying unread message counter.

Rendering authenticated user avatar.

Committing and synchronizing frontend updates.

Introduction to the testing and DevOps phase with repository overview.

Configuring the testing environment for the Go backend with Fiber and MongoDB.

Writing automated tests for the user registration endpoint.

Implementing automated tests for login authentication logic.

Automating backend tests using CI workflows.

Setting up Cypress for frontend end-to-end testing.

Writing end-to-end tests for authentication flows.

Improving CI workflows for better reliability and structure.

Automating frontend integration tests inside CI pipeline.

Containerizing the backend service using Docker.

Creating a Docker image for the frontend application.

Running the complete system using Docker Compose orchestration.

Automating Docker image builds and pushes via CI/CD.

Introduction to the realtime architecture phase.

Designing the structure for realtime gRPC services.

Building the realtime chat server using WebSockets.

Creating mock logic for testing friend retrieval.

Implementing connection and session management logic.

Testing WebSocket communication in the backend.

Defining gRPC proto contracts for chat services.

Implementing friend retrieval via gRPC server.

Saving chat messages using gRPC communication.

Connecting realtime services with gRPC clients.

Designing realtime notification architecture.

Defining proto contracts for notification services.

Implementing the gRPC notification server.

Sending notifications through WebSocket channels.

Connecting API server to gRPC notification client.

Integrating notification gRPC client into backend logic.

Handling realtime notifications in frontend state.

Displaying realtime alerts in navigation bar.

Rendering live notifications inside UI component.

Committing realtime integration updates.

Managing realtime chat state in frontend.

Displaying online/offline users dynamically.

Handling bidirectional realtime messaging.

Displaying live message counters in navigation.

Extending pipeline to support realtime containers.

Introduction to the application upgrade phase.

Reviewing system behavior before applying upgrades.

Improving UI responsiveness and mobile compatibility.

Implementing dynamic scrolling for smoother post loading experience.

Enhancing chat UI for better mobile responsiveness.

Improving post creation workflow and UI structure.

Refactoring authentication component for better UX and validation.

Extending backend model to support improved comment structure.

Enhancing backend logic for creating posts.

Improving comment insertion and validation logic.

Optimizing post retrieval endpoint for performance and scalability.

Implementing secure comment deletion functionality.

Improving profile data retrieval logic.

Synchronizing notification data with updated user information.

Refactoring frontend post handling logic.

Improving UI structure for post updates.

Enhancing post detail display and interactions.

Debugging and stabilizing notification behavior.

Refactoring user state management logic.

Improving profile interaction logic.

Enhancing profile UI layout and responsiveness.

Resolving display and state issues in profile posts.

Refactoring backend structure for better maintainability.

Merging realtime notification service into main backend.

Validating notification behavior after integration.

Integrating realtime chat into unified backend service.

Ensuring chat stability after architectural changes.

Introduction to Redis and caching fundamentals.

Implementing caching for profile post retrieval.

Optimizing global post retrieval using Redis cache.

Improving automation and deployment reliability.

Fixing issues introduced during upgrade phase.

Enhancing authentication with refresh token support.

Introduction to distributed system deployment phase.

Understanding distributed architecture fundamentals.

Designing scalable multi-node system architecture.

Running the system in standalone deployment mode.

Simulating distributed behavior in local environment.

Exploring Kafka for inter-service communication.

Setting up a local Kafka cluster environment.

Initializing Kafka-based application commands.

Implementing Kafka management layer.

Building service heartbeat mechanism (part 1).

Continuing heartbeat monitoring logic (part 2).

Finalizing heartbeat and failover logic.

Managing distributed messages via Kafka topics.

Handling distributed notifications through Kafka.

Tracking online/offline users across nodes.

Building distributed chat hub layer.

Connecting WebSocket handlers with Kafka backend.

Creating realtime notification hub for distributed system.

Implementing WebSocket client for distributed notifications.

Testing distributed demo application behavior.

Updating repository after distributed integration.

Refactoring chat hub for distributed compatibility.

Improving WebSocket connection management.

Building bridge between API and Kafka notifications.

Enhancing distributed notification management logic.

Running system-wide validation after changes.

Resolving message delivery issues.

Preparing frontend for Kubernetes deployment.

Setting up Kubernetes cluster and dashboard locally.

Advanced Performance Optimization

Caching Strategies and Best Practices

Distributed Caching with Redis

Background Jobs Implementation

Working with Hangfire

Logging with Serilog

Structured Logging and Monitoring

Health Checks Configuration

Application Monitoring Basics

CI/CD Overview

Kubernetes – Creating Horizontal Pod Autoscaler (HPA)

Automating Docker Deployment using PowerShell Script

Automating Kubernetes Deployment with PowerShell

Applying Network Policies & Autoscaling via Deployment Script

Testing Deployment Script & Debugging Kubernetes YAML Files

Advanced Debugging for Kubernetes Application Issues

Creating Cleanup Shell Script for Kubernetes Environment

First Full Kubernetes Deployment Test & Validation

Final Production Test – Application Running Successfully on Kubernetes