Build an app with React, Redux and Firestore from scratch
You will start by learning the fundamentals of React, including components, state management, and routing.
The course then dives into Redux, covering actions, reducers, and the Redux store.
Once you have a solid grasp of React and Redux, you’ll integrate Cloud Firestore, Google’s NoSQL document database, into your application.
You’ll learn how to design an effective database structure, perform CRUD operations, and handle authentication with Firebase Authentication.
You’ll also learn how to implement user profiles, image uploads, chat functionality, and a following/followers system.
Additionally, you’ll explore advanced topics like pagination, data consistency, and security rules to ensure your application is robust and secure.
Throughout the course, you’ll gain hands-on experience with various libraries and tools, such as React Hook Form for form handling, Google Maps integration for location-based features, and Cloud Functions for serverless backend functionality.
You’ll learn best practices for structuring your React components, managing state with Redux, and integrating with Cloud Firestore.
Instagram Firestore App Clone | Swift 5 + iOS 14 | MVVM
You’ll start by setting up the project and configuring the main UI, including the tabbed interface and feed collection view.
Next, you’ll dive into user authentication, creating login and registration pages with form validation.
You’ll integrate Firebase for user authentication and learn how to upload profile photos.
The course covers fetching and displaying user data from Firestore, setting up user profiles, and implementing the follow/unfollow functionality.
A significant portion of the course focuses on uploading and displaying posts in the feed.
You’ll learn how to select images, create a custom input text view, upload posts to Firebase Storage, and fetch posts from the API.
The course also covers post comments, likes, and notifications, including real-time updates and handling different notification types.
You’ll build a user feed that displays posts from followed users, updating it dynamically based on follow/unfollow actions and new posts.
The course covers sorting posts and notifications by timestamp, implementing search functionality, and fixing various bugs along the way.
You’ll gain hands-on experience with Swift, iOS development, Firebase, and the MVVM architecture pattern.
Twitter SwiftUI Clone | iOS 14 & Swift 5 | Firestore | MVVM
You’ll start by creating the main user interface components like the tab view, floating action button, and scrollable tweet list.
The search functionality will be implemented with a search view and bar.
Next, you’ll build the messaging framework, including the conversations view and chat interface.
The chat view will have custom bubble UI and integrate mock data initially.
You’ll then refactor it to fetch real messages from Firestore.
Starting a new chat and navigating between views will also be covered.
The user profile section is quite extensive.
You’ll create the profile header, action buttons, filter, and upload tweet UI.
Authentication flows like login, registration with image picker will be built.
Firebase integration for user authentication and Firestore for storing user data is a key part.
The course dives deep into core Twitter features - following/unfollowing users, uploading/fetching tweets, liking/unliking, and checking if a user liked a tweet.
You’ll build the tweet detail view and learn to fetch and display user tweets with filtering and lazy loading.
The direct messaging aspect covers sending messages, fetching recent conversations, starting chats from the messages tab, and fetching chat messages.
You’ll also implement user stats like follower/following counts and message users directly from their profiles.
You will learn MVVM architecture, view presentation, and navigation patterns along the way.
iOS 13 & Swift 5: Chat App With Firestore | MVVM
You’ll start by configuring the project and setting up the home screen with a navigation bar and table view for displaying messages.
Next, you’ll dive into creating the login and sign-up user interfaces along with their respective view models.
This includes form validation, selecting a profile image, and integrating with Firebase for user authentication.
The course covers keeping users logged in, error handling with progress HUDs, and fetching user data from Firestore.
Once the authentication is set up, you’ll build the core functionality of the app: the chat screen.
You’ll create a custom input accessory view for sending messages, set up message cells, and implement the MessageViewModel to handle messaging logic.
The course then guides you through uploading and fetching messages from Firestore, ensuring real-time updates with dynamic cell sizing.
The course doesn’t stop there – you’ll also learn how to upload and fetch conversation data, populate the table view with conversations, and create a user profile section.
This includes building the profile UI, populating it with user data from Firestore, setting up a ProfileViewModel, adding a logout button, and implementing action handlers for various profile options.
Throughout the course, you’ll encounter bug fixes and optimizations, such as resolving duplicate message issues and displaying error messages to users.
Additionally, you’ll learn how to implement a search functionality, allowing users to find and connect with others.
Firebase Firestore for iOS
The course starts by introducing you to Firestore, Google’s cloud-hosted NoSQL database.
You’ll learn what Firestore is and how to set up a project to use it.
This initial section gets you familiar with the core concepts before diving into building an app.
Next, you’ll build the UI for an app that allows users to add thoughts or ideas.
You’ll make your first database entry in Firestore, storing the thought data.
The course then guides you through setting up the main view controller to fetch and display these thoughts from Firestore.
You’ll cover sorting and filtering the data.
Once you can read and write data, the course teaches you how to update individual documents in the database.
This is crucial for building apps that let users modify their data over time.
The course then covers Firestore Authentication, which allows you to securely identify and authenticate users.
You’ll build a login flow UI and implement user creation and login functionality using Firebase Authentication.
With authentication in place, you’ll set up a view controller for displaying comments on the thoughts users have posted.
You’ll create a CommentClass and table view to display the comments data pulled from Firestore.
The course dives into using Firestore Transactions to handle operations that need to be atomic.
To control data access, you’ll learn about Firestore Security Rules.
The course provides an introduction to security rules and guides you through implementing protocols to read/write comments based on the authenticated user.
You’ll set up rules for deleting and updating comments, as well as more advanced security for the thought data itself.
Throughout the course, you’ll work on a real project, gaining hands-on experience with core Firestore features like reading/writing data, querying, authentication, security rules and more.
Tinder Firestore Clone | Swift 5 & iOS 13 | MVVM
The course takes you through building a Tinder-like app from scratch, covering various aspects of iOS development and integrating with Firebase’s Cloud Firestore.
You’ll start by building the home page UI, including setting up the root view controller, creating custom card views, and implementing swiping gestures using pan gestures.
The course then dives into creating user models and view models, allowing you to display user data on the card views and cycle through user photos.
Authentication is a crucial part of any modern app, and this course covers it in detail.
You’ll learn how to create login and registration UI, including custom text fields and form validation using view models.
The course then guides you through user authentication with Firebase, registering users, uploading information to Cloud Firestore, and logging in with credentials.
Once authentication is set up, you’ll fetch user data from Cloud Firestore, create user objects in code, and fetch all users to populate the card views.
The course also covers loading user images and implementing a user settings page, where users can update their information, age preferences, and profile photos.
Moving on, you’ll learn how to save user photos and data to Cloud Firestore, as well as implementing a user profile page with segmented bars and cycling through user photos.
The course then dives into saving swipes, likes, and dislikes to Cloud Firestore, performing swipe animations, and handling button presses.
Matching is a core feature of a dating app, and this course covers it extensively.
You’ll learn how to check if a match exists, present a match view with custom buttons and animations, and create a match view model to handle button actions.
The course also covers omitting swiped users from the deck and setting up match messaging.
Finally, the course touches on bug fixes, query filters to omit the current user from the deck, creating a message controller UI, fetching and displaying matches, and handling user refreshes and authentication bugs.
SwiftUI WhatsApp Clone | MVVM | Cloud Firestore | iOS 15
This course covers building a WhatsApp clone app using SwiftUI, MVVM architecture, and Cloud Firestore.
You’ll start by setting up the project and creating authentication screens for login and registration.
The main user interface will include tabs for conversations, settings, and more.
For the settings page, you’ll build an edit profile view to update the user’s status and profile image.
The conversations screen will display recent chats, and you can start new conversations by searching for users.
The core functionality involves building the chat view with custom bubble and message UI components, along with an input view for sending messages.
You’ll integrate Firebase for user authentication and use Cloud Firestore to store and retrieve user data, messages, and recent conversations.
The course dives into uploading profile photos to Firebase Storage, fetching user data from Firestore to populate the UI, and implementing real-time messaging.
You’ll learn how to structure the messaging backend, create data models for messages and recent conversations, and update the UI accordingly.
Throughout the course, you’ll encounter bug fixes, view model refactoring, and optimizations to improve the app’s performance and user experience.
Xamarin & Firebase: Authentication and Firestore for Xamarin
The course starts by covering the fundamentals of source control with Git and GitHub, ensuring you have a solid grasp of version control for your projects.
Moving on, you’ll dive into Xamarin basics and the MVVM pattern.
You’ll learn how to install the Xamarin tools on both Mac and Windows, create new Xamarin projects in Visual Studio 2019, and work with XAML for defining user interfaces.
The course also covers essential concepts like data binding, the INotifyPropertyChanged interface, ObservableCollection, and the ICommand interface – all crucial for mastering the MVVM pattern in Xamarin.
The real highlight, however, is the comprehensive coverage of Firebase authentication and Cloud Firestore databases.
You’ll build a user interface for registration and login, configure your iOS and Android apps to use Firebase, and implement platform-specific Firebase authentication using dependency services.
When it comes to Cloud Firestore, the course walks you through setting up the database, inserting documents into collections, reading documents to display data in a ListView, navigating to a details page, updating documents, and even deleting documents.
You’ll learn both the iOS and Android implementations, ensuring you can build robust, cross-platform applications.
But that’s not all – the course also covers mobile DevOps with App Center.
You’ll learn how to set up continuous integration and continuous delivery pipelines, sign your Android and iOS builds for distribution, and even distribute your apps to test groups using App Center’s distribution groups feature.
Firebase Firestore for Android
This course starts with an introduction to Firestore, and guides you through setting up a project to work with it.
You’ll learn how to create a user interface for adding data to Firestore and displaying it in a RecyclerView.
The course covers performing one-time data fetches as well as real-time updates, so your app can stay in sync with the latest data.
You’ll also implement features like liking posts and adding comments with a custom adapter.
Authentication is a crucial aspect, and the course dedicates a section to setting up authentication flows with Firestore.
You’ll create new users, log them in, and secure your app’s data with Firestore’s built-in security rules.
The course dives deep into security rules, teaching you how to set up interfaces and advanced rules to control data access and modifications.
You’ll learn how to delete and update comments, as well as implement rules for deleting thoughts (posts).
Throughout the course, you’ll work on a real-world project, giving you hands-on experience with Firestore’s features.
Flutter News Portal App-Firestore Backend(Android&ios App)
The course takes you through building a comprehensive news app for Android and iOS using Flutter and Firebase’s Cloud Firestore.
You’ll start by creating the project and setting up the navigation drawer.
Then, you’ll connect the app to Firebase and Firestore, allowing you to fetch and display real data.
The course covers designing the latest post section, complete with image loading and content display.
A carousel slider is implemented to showcase featured content.
You’ll also learn how to create custom button designs.
Separate view and controller files are created, demonstrating proper code organization.
The core functionality revolves around different news categories like international, local, sports, and politics.
For each category, you’ll build a tab controller, fetch data from Firestore, design the UI, and create details pages with image galleries.
Along the way, you’ll learn how to use essential Flutter widgets and integrate them with Cloud Firestore’s real-time database capabilities.
The course covers implementing refresh indicators and other extra features to enhance the user experience.
This hands-on project will solidify your understanding of Flutter development, Firebase integration, and building real-world applications.