Welcome to the documentation of my first week as an intern! This week, I started with setting up essential tools and dived deep into understanding and using GitHub Desktop. Here's a day-by-day breakdown of my experiences and learnings.

• Created GitHub Account: Sign up here.
• Installed GitHub Desktop: Set up GitHub Desktop on my workstation.
• Connected GitHub Account: Linked my GitHub account to the desktop application.
• Cloned Repository: Cloned my first repository to the local machine.

• Branch Management: Learned to create, switch, and delete branches.
• Merge Conflicts: Introduced to merge conflicts and how to resolve them using GitHub Desktop.
• History and Changes: Explored viewing commit history and changes.

• Branch Creation: Created a feature branch for a small project.
• Merge Practice: Practiced merging branches and resolving conflicts.

• Pull Requests: Created my first pull request (PR) and understood the review process.
• Reviewing Code: Learned how to review code changes in a PR.
• Merging PRs: Merged PRs after reviews and resolved any issues.

• PR Workflow: Understood the complete PR workflow from creation to merging.
• Code Review: Participated in a code review session with my mentor.

• Stashing Changes: Learned to stash and apply changes.
• Reverting Commits: Explored how to revert commits and reset branches.
• Git Ignore: Created a .gitignore file to exclude unnecessary files.

• Stash Management: Successfully stashed changes and reapplied them later.
• Safe Reverts: Practiced safely reverting changes to keep the repository clean.

• Linear Account: Signed up for Linear using this link.
• Slack Channel: Joined our team channel on Slack through this invite link.
• Syncing Repositories: Learned to sync local changes with the remote repository.
• Working Offline: Understood how to work offline and push changes later.
• Tagging: Created tags to mark specific points in the repository history.

• Collaboration Tools: Set up essential tools for project management and communication.
• Synchronization: Kept the local and remote repositories in sync effectively.
• Offline Work: Managed to work offline and push changes when back online.
• Tagging: Used tags to organize the repository history for easy navigation.

This week was incredibly productive, and I learned a lot about using GitHub Desktop to manage repositories effectively, as well as setting up essential tools for project management and communication. The hands-on experience with various features and workflows has set a solid foundation for the rest of my internship.

Stay tuned for more updates as I continue my journey!

Welcome to the documentation of my second week as an intern! This week, I focused on learning about CRUD operations and implementing a CRUD application. Here's a day-by-day breakdown of my experiences and learnings.

![Day 1]

• Watched YouTube Tutorial: Gained a solid understanding of CRUD operations (Create, Read, Update, Delete).
• Resource: YouTube CRUD Tutorial

• Development Environment: Set up the development environment and initialized the CRUD application project.
• Dependencies: Installed necessary dependencies.
• Project Structure: Created the initial project structure.

• Environment Setup: Successfully set up the workspace.
• Project Initialization: Initialized the project with all necessary configurations.

![Day 3]

• Create Functionality: Developed the functionality to add new data entries.
• Read Functionality: Implemented the functionality to view existing data entries.
• Database Setup: Created the data model and set up the database.
• API Endpoints: Developed API endpoints for Create and Read operations.

• Data Model: Successfully created the data model.
• Database Integration: Integrated the database with the application.

• Update Functionality: Developed the functionality to modify existing data entries.
• Delete Functionality: Implemented the functionality to remove data entries.
• Testing: Tested the Update and Delete operations to ensure they work correctly.

• API Development: Successfully developed and tested Update and Delete endpoints.
• Bug Fixes: Identified and fixed initial bugs in the implementation.

• Testing: Wrote test cases for each CRUD operation.
• Unit and Integration Testing: Performed unit testing and integration testing.
• Documentation: Documented the application and its API endpoints.

• Comprehensive Testing: Ensured the application works as expected through rigorous testing.
• Documentation: Created detailed documentation for future reference.

Below is an example of testing the CRUD API using Postman:

This week was incredibly productive, and I learned a lot about implementing and testing CRUD operations. The hands-on experience with API development and testing has been invaluable, setting a solid foundation for future backend development tasks.

Stay tuned for more updates as I continue my journey!

Welcome to the documentation of my third week as an intern! This week, I focused on understanding the VolDebug app and developing various APIs. Here's a day-by-day breakdown of my experiences and learnings.

• Downloaded VolDebug App: Downloaded the zip file of the VolDebug app.
• App Observation: Thoroughly observed the app to understand where APIs can be utilized.

• Blog Standards API: Developed Create, Read, and Update APIs for blog standards.
• Blog Image API: Created APIs for managing blog images.

• CRUD Operations: Successfully implemented CRUD operations for blog standards.
• Image Management: Developed APIs to handle blog images effectively.

• Delete API for Blog Standards: Created Delete API for blog standards.
• Delete API for Blog Image: Developed Delete API for blog images.
• Schema Creation: Designed the schema for blog titles.

• Deletion Handling: Implemented deletion functionalities for blog standards and images.
• Schema Design: Created an efficient schema for managing blog titles.

• Blog Title API: Developed Create, Read, Update, and Delete APIs for blog titles.

• Complete CRUD: Implemented full CRUD functionalities for managing blog titles.

• API Relationships: Created the relationship between blog titles and images in the API.

• Data Relations: Successfully established and managed relationships between different data entities.

Below is an example image related to the API development process:

This week was highly productive, and I enhanced my skills in API development and data management. The experience of working with the VolDebug app and creating various APIs has been invaluable, providing a deeper understanding of backend development.

Stay tuned for more updates as I continue my journey!

Welcome to the documentation of my fourth week as an intern! This week, I focused on building APIs for managing blog information, specifically targeting the short description and long description models. Additionally, I established relationships between the blog title and these descriptions. Here's a day-by-day breakdown of my experiences and learnings.

• Downloaded VolDebug App: Downloaded the zip file of the VolDebug app.
• App Observation: Thoroughly observed the app to understand where APIs can be utilized for managing blog information.

• Short Description API: Developed CRUD APIs for managing short descriptions of blog posts.
• Long Description API: Implemented APIs for handling detailed long descriptions of blog posts.

• Successfully implemented CRUD operations for both short and long description APIs.
• Ensured data consistency and validation in API operations.

• Relationship Setup: Established relationships between blog titles and their corresponding short and long descriptions.
• Data Integration: Ensured seamless integration and synchronization of data between different API endpoints.

• Achieved cohesive data management by linking blog titles with descriptive content.
• Enhanced data retrieval efficiency through established relationships.

• Schema Refinement: Optimized schema design for blog titles to accommodate relational data structures.
• Performance Tuning: Fine-tuned API endpoints for improved response times and scalability.

• Designed an efficient database schema to support relational data handling.
• Implemented performance enhancements to meet application requirements.

• Unit Testing: Conducted rigorous testing of APIs to ensure functionality and reliability.

• Final Review: Reviewed code with team members for feedback and improvement.

• Thoroughly tested APIs to validate CRUD operations and data relationships.
• Created comprehensive documentation to facilitate ease of use and maintenance.
• Incorporated feedback for further refinement of code and documentation.

This week was a significant learning experience in API development and relational data management. I gained practical skills in building robust APIs, establishing data relationships, optimizing performance, and ensuring thorough testing and documentation. These skills are crucial for advancing in backend development and ensuring efficient data handling in applications.

Stay tuned for more updates as I continue my journey!