The Web Development for Beginners program provides a beginner-friendly path to learning HTML, CSS, responsive design, typography, animations, Flexbox, CSS Grid, GitHub, and website deployment.
You can start learning free by checking the available preview materials within one of the individual courses before choosing complete enrollment.
This four-course learning program is designed for complete beginners, aspiring developers, entrepreneurs, and creative professionals who want to understand how websites are designed, built, and published.
The lessons combine web development fundamentals with practical projects, helping you create responsive and visually appealing pages that work across desktops, tablets, and mobile devices.
During the program, you will explore:
You will also build example web pages and create a mini portfolio website that can be published online.
Learn how the web works, create static pages with HTML and CSS, choose a hosting service, use GitHub, and publish a website.
Explore typography, web fonts, color theory, gradients, CSS transitions, 2D and 3D transformations, and keyframe animations.
Learn Flexbox, responsive web design, mobile-first development, and techniques for creating layouts that adapt to different screen sizes.
Explore advanced CSS Grid and Flexbox techniques to control content, spacing, positioning, rows, columns, and modern web page layouts.
This program is ideal for:
No advanced programming experience is required.
Follow these steps to explore the available free preview:
Preview availability and the amount of accessible content may vary. Complete lessons, assignments, projects, and the certificate may require full enrollment.
Web development is a valuable digital skill for creating portfolio websites, landing pages, business websites, and online projects.
This beginner-friendly program gives you a structured path from basic HTML and CSS to responsive layouts, animations, GitHub, and website deployment.
Explore HTML, CSS, responsive design, Flexbox, CSS Grid, animations, GitHub, and practical website development.
Start Learning FreePreview availability and included learning materials may vary.
The Web Applications for Everybody program offers a structured introduction to web application development using PHP, MySQL, SQL, JavaScript, jQuery, and JSON.
You can also start learning free by exploring the preview materials available within an individual course before deciding whether you need full access.
This intermediate-level program includes four courses designed to explain how browsers, servers, databases, and programming languages work together to create interactive web applications.
The program follows a flexible, self-paced format and can typically be completed in approximately two months when studying around ten hours per week.
It is most suitable for learners who already understand basic HTML, CSS, JavaScript, or general programming concepts.
Throughout the program, you will develop practical skills in:
You will also complete increasingly challenging web development assignments that can help strengthen your developer portfolio.
Learn how browsers communicate with web servers while exploring PHP syntax, variables, arrays, loops, error handling, forms, and development environments such as XAMPP or MAMP.
Develop foundational SQL and database design skills. You will work with multiple tables, foreign keys, JOIN operations, and many-to-many relationships.
Combine PHP and MySQL to create complete database applications with multiple screens and Create, Read, Update, and Delete functionality.
Explore JavaScript, object-oriented programming, jQuery, JSON, event handling, Ajax, and browser-based interaction.
This learning path is suitable for:
Follow these steps to access the available free preview:
You can then watch the videos included in the preview and explore the course structure before choosing full enrollment.
The preview does not necessarily include every lesson, graded assignment, project, or certificate. Availability may also vary by course and location.
Web development requires more than creating attractive pages. Developers must also understand servers, databases, application logic, user sessions, and data exchange.
This program brings these skills together through practical projects that show you how to create functional, database-backed web applications.
Begin with the available preview and start developing valuable PHP, SQL, MySQL, JavaScript, and database development skills today.
Explore PHP, MySQL, SQL, JavaScript, jQuery, JSON, and practical database-driven web development through the available course preview.
Start Learning FreePreview availability and included materials may vary.
The Unity C# Scripting – Complete C# for Unity Game Development program provides a practical learning path for aspiring game developers who want to understand game programming, player controls, physics, artificial intelligence, mobile development, and reusable C# scripts.
You can also start learning free by previewing one of the individual courses before choosing full access.
This three-course program covers essential Unity game development skills, including:
The program also includes practical projects that help you apply what you learn by creating interactive game systems and complete playable experiences.
This learning path is suitable for:
Although the full program is considered intermediate, the first course begins with Unity setup and basic C# scripting concepts.
Follow these steps to access the available free preview:
You can then watch the available preview videos and explore the course content before deciding whether to continue with full access.
C# gives you control over how your game behaves.
With Unity C# scripting, you can create:
These skills can help you build stronger portfolio projects and prepare for opportunities in game development, interactive applications, and mobile development.
This program combines programming concepts with practical game development projects, making it a useful option for learners who want more than theoretical lessons.
Start with the free preview, explore the first course, and begin developing your Unity C# skills today.
Explore Unity C# scripting, 2D and 3D game development, artificial intelligence, physics, mobile controls, and reusable game systems.
Start Learning FreeHowever, becoming a game developer requires more than watching demonstrations or memorizing code. You need to understand how player controls, physics, cameras, scoring, animations, sound, user interfaces, achievements, advertising, and mobile deployment work together inside a complete game.
The Unity Android Game Development specialization provides a practical learning path built around seven different 2D and 3D Android game projects.
You may be able to start learning free by opening an individual course and checking whether selected Preview lessons are available. This can help you explore the teaching style and selected course content before deciding whether you need complete access.
Throughout the program, you will use Unity and C# to create playable Android games, develop advanced mechanics, add social and achievement features, integrate advertising, manage source code, prepare builds, and understand how mobile games are published.
Mobile games combine several technical and creative disciplines.
A professional mobile game may need:
Unity provides a visual development environment for bringing these systems together.
C# provides the programming logic behind player actions, gameplay rules, scoring, enemies, interfaces, achievements, and game progression.
Learning both Unity and C# can prepare you to build:
This is a three-course, project-based learning program designed to introduce Android game development through practical examples.
The current structure includes:
The suggested learning schedule is approximately:
Although it is classified as beginner level, familiarity with the Unity interface and basic C# scripting can make the more advanced project sections easier to follow.
The program uses seven different projects to teach a broad selection of game-development skills.
A 3D Zigzag project can introduce:
This type of project helps you understand how simple mechanics can create an engaging endless game.
Tappy Ball introduces touch-based input and timing.
You may practise:
A slicing-style game can teach:
A football project can develop skills involving:
An endless-runner project may include:
A brick-breaking game introduces:
A 2D racing project can cover:
Together, these seven projects provide experience across arcade, sports, racing, physics, endless-runner, and casual game mechanics. (Coursera)
Estimated duration: 13 hours
The first course introduces the Unity Android development environment and the main concepts required to build and publish mobile games.
You will explore:
The course focuses on creating working mechanics and understanding how Unity organizes a game project.
Unity includes several important panels.
The Scene view is where you arrange objects, environments, cameras, lighting, and gameplay elements.
The Game view displays what the player will see.
The Hierarchy contains the GameObjects inside the active scene.
The Inspector allows you to review and change components, scripts, positions, materials, and settings.
The Project window stores:
Understanding these areas helps you navigate projects efficiently.
Unity games are built using GameObjects.
A GameObject may represent:
Components add functionality to GameObjects.
Common components include:
For example, a player GameObject may include a Transform, Rigidbody, Collider, Animator, and movement script.
Unity physics can simulate:
A Rigidbody allows an object to participate in physics.
A Collider defines the area used for collision detection.
Collision scripts can trigger:
The camera should keep important gameplay visible.
A camera-follow script can track the player while maintaining a fixed distance.
using UnityEngine;
public class CameraFollow : MonoBehaviour
{
[SerializeField] private Transform target;
[SerializeField] private Vector3 offset;
private void LateUpdate()
{
transform.position = target.position + offset;
}
}
Smooth camera behavior improves readability and player comfort.
Mobile games need clear interfaces for:
A good mobile interface should use:
Animations make gameplay feel more polished.
They may be used for:
Unity’s Animator system can manage transitions between animation states.
Estimated duration: nine hours
The second course introduces monetization, advanced game mechanics, game-art workflows, and version control.
Topics include:
The course teaches how to develop games that can be prepared for distribution and monetization.
Mobile developers may monetize games through:
The specialization focuses on video-ad integration.
Interstitial ads appear between gameplay moments, such as:
They should not interrupt important player actions.
Rewarded videos give players an optional benefit for watching an advertisement.
Rewards may include:
Rewarded ads should clearly explain what the player will receive.
Monetization should not damage the player experience.
Good practices include:
A sustainable game should balance business goals with player satisfaction.
Version control tracks changes to your game project.
Git can help you:
GitHub and Bitbucket provide online repository hosting.
A useful Unity .gitignore file should exclude generated folders such as:
Version control is especially important when projects contain multiple scripts and scenes.
Game art includes:
Developers should consider:
Optimized art helps games run efficiently on Android devices.
Estimated duration: 18 hours
The final course develops advanced scripting and engagement features.
You will study:
The goal is to help you build complete Android games with stronger gameplay and player-engagement systems.
C# scripts may control:
A simple score manager might look like this:
using UnityEngine;
using TMPro;
public class ScoreManager : MonoBehaviour
{
[SerializeField] private TMP_Text scoreText;
private int score;
public void AddScore(int amount)
{
score += amount;
scoreText.text = $"Score: {score}";
}
}
Separating responsibilities into different scripts can make the project easier to maintain.
A game may move through several states:
A central game manager can control these transitions.
This helps coordinate:
Achievements reward players for completing specific goals.
Examples include:
Achievement systems can improve motivation and replay value.
A professional achievement system should:
Leaderboards allow players to compare performance.
They may rank players by:
Leaderboards can increase competition and engagement, but they should also include protection against manipulated scores.
Social features may include:
These features can encourage users to return and interact with the game.
The official course outcomes specifically include designing social features intended to improve player interaction and retention.
Before publishing a game, test:
You may also need to configure:
A release workflow may include:
Publishing requirements can change, so always review the latest app-store policies before releasing a game.
The program’s seven games allow you to practise different technical areas:
| Game | Main Skills |
|---|---|
| 3D Zigzag | Movement, platforms, camera, scoring |
| Tappy Ball | Touch controls, physics, obstacles |
| Fruit Ninja | Spawning, slicing, effects, scoring |
| 3D Flick Football | Swipe input, ball physics, goals |
| 3D Runner | Endless movement, obstacles, difficulty |
| 2D Bricks Breaker | 2D physics, levels, collision |
| 2D Racing | Vehicle control, tracks, checkpoints |
By completing several distinct projects, you can demonstrate wider experience than a portfolio containing only one game type.
The specialization introduces or uses:
The specialization may be suitable for:
Learners can develop practical experience through seven complete projects.
The projects provide a reason to practise C# in a visual and interactive environment.
Developers can expand into Android game creation.
Students can build several games for a portfolio.
Creative professionals can learn how visual assets are implemented inside Unity.
Freelancers can develop prototypes and casual games for clients.
Independent creators can explore building and monetizing mobile games.
The complete specialization is not officially available entirely free.
However, an individual course may sometimes display selected Preview lessons.
Follow these steps:
The Preview option may not be available for every course, account, location, or device.
The official program information states that complete access is not free. When Preview is unavailable, check whether the enrollment page provides:
Complete lessons, graded projects, assignments, and the certificate may require paid enrollment. (Coursera)
Create the projects in your own Unity environment rather than only watching videos.
Customize:
Practise classes, methods, conditions, loops, collections, events, and object-oriented programming.
The Unity Editor cannot perfectly reproduce every mobile-device behavior.
Commit your project after completing each major feature.
Review:
For each game, include:
After building sufficient experience and additional projects, learners may explore roles such as:
Completing the specialization does not guarantee employment.
Employers and clients may also evaluate:
You can check each individual course for selected Preview lessons. Free access is not guaranteed.
It is listed as beginner level, although basic familiarity with Unity and C# can be helpful.
The specialization contains three courses.
The estimated completion time is approximately four weeks at around 10 hours per week.
The program includes seven 2D and 3D game projects.
Yes. C# scripting is a major part of the learning path.
Yes. The program focuses on creating, building, and publishing games for Android.
Yes. The projects include both 2D and 3D games.
Yes. The curriculum covers interstitial and rewarded video advertisements.
Yes. Player-engagement and social features are covered.
Yes. Git, GitHub, Bitbucket, and version-control practices are included.
Yes. Android build and publishing processes are part of the program.
No. Preview access generally does not include complete graded activities or the certificate.
Master Unity, C#, Android development, player controls, physics, animations, mobile UI, advertisements, achievements, leaderboards, Git, GitHub, and Android game publishing.
Open an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded projects, and the certificate may require paid enrollment. Financial aid may be available for eligible learners.
A complete social application needs user accounts, secure authentication, profile management, image uploads, database integration, API communication, dynamic content, social interactions, notifications, and a reliable server-side architecture.
The SwiftUI & Node.js Full-Stack Development Specialization provides a hands-on path for learners who want to understand how a native iOS interface connects with a custom back-end service.
Instead of studying SwiftUI and Node.js separately, you will use them together to build practical applications, including a Notes app and a functional Twitter-style social platform.
You may be able to start learning free by opening one of the individual courses and checking whether a Preview option is currently available. Preview access may include selected lessons, but the complete specialization, projects, assessments, and certificate may require paid enrollment.
Many mobile-development courses concentrate only on the visible interface.
However, real-world applications also need a back end that can:
SwiftUI provides the tools needed to create the native iOS experience, while Node.js supports the server-side functionality behind it.
Learning both sides helps you understand the complete application flow:
This full-stack workflow is central to modern mobile development.
This beginner-friendly specialization consists of three courses and is designed to be completed in approximately four weeks at 10 hours per week.
The program is flexible and self-paced.
The three courses are:
The learning path progresses from environment configuration and basic application integration to secure API development, authentication, image handling, social features, profile management, and real-time notifications. (Coursera)
By following the complete program and completing the practical projects, you can build skills in:
Estimated duration: nine hours
The first course introduces the tools and architecture required to build a complete mobile and server-side application.
You will learn how to configure:
You will also begin creating RESTful APIs and connect a mobile interface to back-end services. (Coursera)
Node.js allows JavaScript to run outside the browser.
It is commonly used to create:
A typical Node.js project may contain:
Organizing these parts properly makes the application easier to develop, test, and maintain.
Express is a Node.js framework used to create server-side applications and APIs.
An API endpoint might allow the iOS application to:
Common HTTP methods include:
GET to retrieve informationPOST to create informationPUT or PATCH to update informationDELETE to remove informationA simple Express route might look like this:
app.get("/api/tweets", async (req, res) => {
const tweets = await Tweet.find().sort({ createdAt: -1 });
res.json(tweets);
});
The mobile application can request this endpoint and display the returned content.
MongoDB is a document-oriented database that stores information in flexible records.
A social application may need collections for:
A tweet document might contain:
{
"authorId": "user_105",
"text": "Building an iOS app with SwiftUI and Node.js",
"imageUrl": "https://example.com/image.jpg",
"createdAt": "2026-07-03T10:00:00Z"
}
MongoDB’s flexible data model can be useful when developing applications whose content structure may evolve.
Mongoose provides tools for defining and validating MongoDB data inside a Node.js application.
A schema can specify:
This helps protect data quality and makes the database layer easier to manage.
CRUD represents four essential operations:
A social application uses CRUD operations to manage users, tweets, profiles, comments, and notifications.
Learning these operations prepares you to build many other application types, including booking platforms, marketplaces, learning systems, and customer portals.
Estimated duration: six hours
The second course concentrates on the back-end API that supports the Twitter Clone.
You will learn how to:
The course places particular emphasis on secure server-side development and dynamic application behavior. (Coursera)
A registration endpoint may receive:
The server should then:
Professional applications should never store passwords as readable text.
During login, the API should:
Authentication determines who the user is.
Authorization determines which information and features that user is permitted to access.
JSON Web Tokens can represent an authenticated session.
A typical workflow is:
JWT authentication may protect actions such as:
Tokens and signing secrets must be managed carefully.
The API may provide endpoints for:
The server must validate both the submitted content and the user’s authorization.
For example, users should not be able to delete tweets created by another account unless their role explicitly permits it.
Social applications frequently allow users to upload:
Image-processing tools such as Sharp.js can help:
The API should also validate file type, file size, and ownership.
A Twitter-style application may include:
Each feature requires careful coordination between the database, API, authentication layer, and mobile interface.
Estimated duration: 11 hours
The third course connects the API with the SwiftUI application and adds advanced user-facing functionality.
You will work with:
The completed project combines the native iOS experience with the server-side services created during the earlier courses. (Coursera)
SwiftUI is Apple’s declarative framework for creating interfaces.
It can be used to build:
A SwiftUI view describes how the interface should appear based on the current application state.
MVVM stands for:
The model represents application information.
The view displays the interface.
The view model handles presentation logic and connects the interface with the application’s services.
This separation can make an application:
For example, a tweet view model may retrieve tweets from the API and make them available to a SwiftUI list.
The iOS application must send requests to the Node.js API.
A typical request may involve:
Reliable API integration also requires loading indicators and error handling.
The server returns information in JSON format.
Swift models can use Codable to encode and decode this data.
A tweet model might look like:
struct Tweet: Codable, Identifiable {
let id: String
let text: String
let imageURL: String?
let createdAt: String
let author: User
}
Accurate data models help ensure that the application correctly interprets the API response.
Network requests should not freeze the application interface.
Swift concurrency supports asynchronous operations using features such as:
asyncawaitThese tools help the app retrieve data while remaining responsive.
The SwiftUI application may include:
The application should clearly communicate:
A profile may display:
Users may also update their profile information and images through protected API requests.
A reusable tweet component may include:
Reusable views help maintain visual consistency across the feed, profile, and search screens.
Notifications can inform users about activities such as:
The application must retrieve or receive notification data and present it clearly.
Even when an application does not use permanent real-time connections, it can periodically refresh notification content through the API.
The specialization includes two major application projects.
The Notes app introduces:
The Twitter Clone combines:
These projects provide experience that can be presented in a mobile-development portfolio. (Coursera)
The program introduces or uses:
The program may be suitable for:
The learning path begins with foundational concepts and does not require previous professional development experience.
Learners can build Swift, SwiftUI, Xcode, and native application skills.
JavaScript developers can expand into Node.js APIs and native iOS integration.
Developers can learn how to design and manage their own application back end.
The specialization covers mobile interfaces, APIs, authentication, databases, and deployment concepts.
Students can complete two practical projects for their portfolios.
Freelancers and founders can better understand how complete social and mobile applications are developed.
You will need access to a Mac capable of running Xcode or a suitable supported development environment or emulator.
A stable internet connection is also required for:
The complete specialization is not offered entirely free, but individual courses may occasionally provide Preview lessons.
Follow these steps:
Preview availability may vary according to the course, account, country, device, and current enrollment options.
When Preview is unavailable, check whether the program provides:
The official program information states that complete course access is not free, but financial aid may be available for eligible learners. (Coursera)
Do not only watch demonstrations. Recreate the API and iOS features inside your own project.
Verify registration, login, profile updates, tweets, and image uploads before connecting them to SwiftUI.
Never publish:
Create separate commits for authentication, database models, API routes, SwiftUI screens, and notifications.
Change the name, branding, colors, interface, and business rules.
Add original features such as:
Explain how SwiftUI, Node.js, Express, MongoDB, JWT, and image processing work together.
After developing sufficient experience and building additional projects, learners may explore roles such as:
Completing the specialization does not guarantee employment.
Employers may also evaluate your Swift knowledge, API-development ability, database skills, authentication experience, project quality, Git usage, problem-solving, testing, and technical communication.
You can check the individual courses for any available Preview lessons. Complete free access is not guaranteed.
Yes. It is currently classified as beginner level.
The program contains three courses.
The estimated completion time is four weeks at approximately 10 hours per week.
Yes. SwiftUI is used to build the native iOS application interfaces.
Yes. Node.js and Express are used to create the application back end.
Yes. MongoDB and Mongoose are used for application data and modeling.
Yes. The program covers user authentication and JWT-based security.
Yes. The main applied project is a full-stack Twitter-style iOS application.
Yes. The API includes image handling and processing.
Yes. The final course includes notification functionality within the SwiftUI application.
Access to a Mac or suitable emulator is required for the native iOS development portions.
Master Swift 5, SwiftUI, Node.js, Express, MongoDB, REST APIs, JWT authentication, profile management, image uploads, tweets, social features, and notifications.
Open an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded projects, and the certificate may require paid enrollment. Financial aid may be available for eligible learners.
Businesses need fast, responsive, data-driven applications that can process payments, authenticate users, retrieve information from APIs, manage content, store data, and deploy reliably to the cloud.
Svelte 5 and SvelteKit provide a modern development approach for creating interactive front-end experiences and complete full-stack web applications.
The Svelte 5 & SvelteKit for Hands-On Modern Web Development Specialization offers a project-focused learning path for developers who want to move beyond isolated tutorials and build complete, functional applications.
You may be able to start learning free by opening one of the individual courses and checking whether selected Preview lessons are available.
Throughout the program, you will create practical projects involving Svelte 5, SvelteKit, reactive state, routing, APIs, Stripe payments, automated email delivery, Sanity CMS, Supabase, user authentication, OAuth, databases, artificial intelligence features, and cloud deployment.
Modern web applications must respond quickly to user actions while managing increasingly complex data and business logic.
A professional application may need to:
Svelte helps developers create interactive interfaces using reusable components and a reactive programming model.
SvelteKit expands those capabilities by providing a complete framework for routing, server-side rendering, data loading, API endpoints, form handling, and deployment.
Together, they can support both front-end and full-stack application development.
Many front-end frameworks perform significant work inside the browser.
Svelte takes a different approach by compiling much of the application during the build process.
This can help developers create applications with:
A Svelte component can include its logic, interface, and styling in one organized file.
This can make components easier to understand and maintain.
SvelteKit is an application framework built around Svelte.
It provides features needed for production web development, including:
SvelteKit allows developers to use the same project for front-end interfaces and server-side functionality.
This makes it useful for building full-stack applications without maintaining completely separate projects for every layer.
The program currently includes four courses and is designed for learners with basic JavaScript knowledge.
The estimated study plan is:
The four courses are:
Each course introduces new skills through a practical project.
By following the complete learning path, you can develop skills in:
Estimated duration: four hours
The first course introduces the essential concepts required to work with Svelte 5 and SvelteKit.
It covers:
The course helps you understand how Svelte applications are structured before progressing into larger projects. (Coursera)
A Svelte component can contain:
A simplified component might look like this:
<script>
let name = "Developer";
</script>
<h1>Welcome, {name}</h1>
<style>
h1 {
color: #ff3e00;
}
</style>
This organization allows developers to keep related logic, content, and styling together.
Components are reusable parts of an interface.
A component may represent:
Reusable components reduce repetition and help maintain consistent application design.
Reactive state allows the interface to update when data changes.
For example:
<script>
let count = 0;
</script>
<button onclick={() => count++}>
Clicked {count} times
</button>
When the value changes, Svelte updates the relevant part of the interface.
Reactive programming is essential for:
Svelte 5 introduces runes for expressing state and reactivity.
Runes can help developers manage:
Understanding this model is important for building modern Svelte 5 applications.
Applications frequently collect information through:
Svelte provides clear patterns for connecting user input to application state.
This allows the interface to validate, display, and process information dynamically.
SvelteKit uses file-based routing.
A page file inside a project can correspond to a URL.
Examples may include:
//products/portfolio/account/books/contactDynamic routes can support URLs such as:
/products/125/articles/svelte-development/users/alexFile-based routing can make application structure easier to understand.
Applications may retrieve data from:
SvelteKit supports server-side and client-side data loading.
Server-side loading can improve:
Client-side fetching can support interactive updates after the page has loaded.
SvelteKit allows developers to add server-side endpoints inside the same application.
An endpoint may:
This helps transform a Svelte interface into a complete full-stack application.
Estimated duration: five hours
The second course focuses on building a responsive product landing page with secure payment processing.
You will learn how to:
The project connects user-interface development with a real payment and email-delivery workflow. (Coursera)
A product landing page may include:
The objective is to guide visitors toward a specific action.
A strong landing page should be:
Stripe provides tools for processing online payments.
A typical payment flow may include:
Payment logic should be handled securely on the server rather than exposing sensitive configuration inside browser code.
A webhook allows Stripe to notify your application when an event occurs.
Possible events include:
The application can verify the webhook and then trigger the appropriate action.
For example, after a successful payment, the system may deliver a digital product by email.
SendGrid can be used to send automated transactional emails.
The application may send:
Combining Stripe webhooks with SendGrid creates a complete automated delivery process.
Webhook requests should be verified before they are trusted.
This helps prevent unauthorized requests from triggering actions such as:
Secure webhook handling is an important part of production application development.
Estimated duration: six hours
The third course focuses on building a professional developer portfolio connected to a headless content-management system.
You will learn how to:
The completed project provides a practical portfolio that can be updated without modifying the application code for every content change. (Coursera)
A developer portfolio can demonstrate:
A professional portfolio may include:
It gives employers and clients a direct way to review your work.
Reusable components may include:
A reusable component system keeps the design consistent and makes future changes easier.
Sanity is a headless content-management system.
A headless CMS stores and manages content separately from the interface that displays it.
It can manage:
The SvelteKit application retrieves this information and displays it dynamically.
A headless CMS can help you:
This architecture is useful for portfolios, blogs, business websites, and product platforms.
Vercel can host SvelteKit applications and provide a public URL.
Before deployment, check:
A live portfolio is more valuable than screenshots because visitors can test the actual application.
Estimated duration: nine hours
The final course focuses on building a data-driven personal book-library application.
It combines:
The project demonstrates how to connect an interactive Svelte interface with authentication, databases, and advanced external services. (Coursera)
A personal book-library application may allow users to:
This project combines front-end, back-end, database, and authentication skills.
Supabase provides tools for:
It can help developers build full-stack applications without creating every infrastructure component from the beginning.
Authentication confirms who the user is.
An authentication workflow may include:
Authenticated applications must also ensure that users can only access their own protected information.
OAuth allows users to sign in through an external provider.
This can simplify onboarding because users do not need to create another password.
The application must still handle:
A book-library database may contain tables for:
Good database design helps maintain:
Image-recognition features can help extract information from uploaded book images.
For example, the application may analyze a cover image and assist with identifying or organizing the book.
This introduces learners to integrating AI-powered services inside a full-stack application.
The application may generate information such as:
Statistics help users understand and interact with their stored information.
The specialization includes three major applied projects:
These projects provide experience with payments, webhooks, APIs, content management, databases, authentication, reusable components, AI integration, and deployment. (Coursera)
The program introduces or uses:
The program may be useful for:
Developers can expand their knowledge into Svelte 5 and SvelteKit.
Front-end developers can learn routing, server-side data loading, CMS integration, and full-stack features.
The program covers APIs, databases, authentication, payments, and deployment.
Developers familiar with another framework can explore Svelte’s compiled and reactive approach.
Freelancers can build landing pages, portfolios, payment systems, and data-driven applications.
Students can create several practical projects for their portfolios.
Entrepreneurs can better understand how modern digital products are developed and deployed.
The complete specialization is not currently available entirely free.
However, an individual course may sometimes provide selected Preview lessons.
Follow these steps:
Preview availability may vary by course, account, device, location, and current enrollment options.
When Preview is unavailable, check whether the enrollment page provides:
Complete courses, graded assignments, projects, and the certificate may require paid enrollment.
Always review the current enrollment and payment conditions before confirming.
Review variables, functions, arrays, objects, asynchronous programming, and modules.
Do not only watch the lessons. Recreate each feature inside your own development environment.
Change the design, content, features, and branding so your portfolio projects are original.
Track your progress and publish clean repositories.
Never publish secret API keys, database credentials, or payment credentials.
Review login, logout, social login, protected data, and session expiration.
Test success, cancellation, failed payments, and webhook verification.
Use semantic HTML, clear labels, keyboard support, visible focus indicators, and sufficient contrast.
Live applications demonstrate your deployment and troubleshooting skills.
After completing the program, consider building:
A strong project could include:
After building sufficient experience and a strong portfolio, learners may explore roles such as:
Completing the specialization does not guarantee employment.
Employers may also evaluate:
You can check individual courses for selected Preview lessons. Free access is not guaranteed.
It is classified as intermediate level. Basic JavaScript knowledge is recommended.
The specialization contains four courses.
The estimated completion time is approximately four weeks at around 10 hours per week.
Yes. The first course covers Svelte 5 components, reactivity, runes, props, and state management.
Yes. SvelteKit is used for routing, server-side data loading, API endpoints, and full-stack development.
Yes. One project integrates Stripe payments and webhooks.
Yes. SendGrid is used to automate digital-product delivery.
Yes. One project uses Sanity CMS.
Yes. The final project uses Supabase and relational database features.
Yes. The full-stack project includes authentication, social login, and secure session management.
Yes. The final project includes image recognition and OpenAI API-related features.
Yes. Deployment tools such as Vercel are included.
No. Preview access generally does not include the complete graded experience or certificate.
Master Svelte 5, SvelteKit, reactive state, runes, routing, server-side data fetching, APIs, Stripe, Sanity CMS, Supabase, authentication, databases, AI integration, and cloud deployment.
Select an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded assignments, projects, and the certificate may require paid enrollment. Financial aid may be available.
Development teams add new features, modify existing pages, fix security issues, improve performance, and release changes across different browsers and operating systems.
Every update creates the possibility that something may stop working.
A login form may reject valid users. A checkout button may become unresponsive. A page may display correctly in one browser but fail in another. A navigation menu may break after a design update.
Test automation helps teams identify these problems faster and more consistently.
The Selenium WebDriver 4 with Python – Zero to Hero Specialization offers a structured learning path for beginners who want to move from basic Python programming to professional web-test automation, reusable frameworks, cross-browser testing, and continuous integration.
You may be able to start learning free by opening one of the individual courses and checking whether selected Preview lessons are currently available.
Throughout the program, you will learn how to write Python automation scripts, control browsers with Selenium WebDriver, locate page elements, handle dynamic content, create reliable test cases, organize automation frameworks, manage test data, use GitHub, and connect automated testing with Jenkins.
Manual testing is important, but repeatedly checking the same application features can take a significant amount of time.
Imagine testing a website after every update and manually confirming that:
Automation allows these repetitive checks to run through scripts.
Selenium WebDriver can control a browser in a way that simulates user actions.
Python provides readable syntax and a large ecosystem for writing, organizing, and maintaining those tests.
Together, Selenium and Python can help teams:
Selenium WebDriver is a browser-automation tool used to control web browsers programmatically.
It can perform actions such as:
A simple Selenium test may:
This allows developers and testers to repeat the same process consistently.
Python is popular in automation because its syntax is relatively clear and readable.
It can be used to:
Python also supports important programming concepts needed for professional automation, including:
The specialization contains three progressive courses:
The learning path is designed for beginners and is estimated at approximately:
No previous automation-testing experience is required.
The program starts with Python fundamentals before introducing browser automation, advanced element location, wait strategies, testing frameworks, logging, data-driven testing, GitHub, Jenkins, and CI/CD.
Throughout the specialization, you will learn how to:
Estimated duration: 12 hours
The first course builds the programming foundation needed for test automation.
It introduces Python before connecting Python scripts with Selenium WebDriver.
Topics include:
Before writing browser tests, you need a working automation environment.
A typical setup may include:
Selenium can be installed through pip:
pip install selenium
A basic Python script can then open a browser:
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)
driver.quit()
This script launches a browser, opens a page, prints its title, and closes the browser.
Variables store information used by your tests.
Examples include:
browser_name = "Chrome"
timeout_seconds = 10
test_passed = True
Common Python data types include:
Automation scripts use these values to store credentials, URLs, expected results, test data, and configuration settings.
Conditional statements allow scripts to make decisions.
Example:
page_title = driver.title
if page_title == "Dashboard":
print("Login test passed")
else:
print("Login test failed")
Conditions can verify:
Loops allow you to repeat actions.
Example:
browsers = ["Chrome", "Firefox", "Edge"]
for browser in browsers:
print(f"Running tests in {browser}")
Loops can be used to:
Functions reduce repeated code.
Example:
def login(driver, email, password):
driver.find_element("id", "email").send_keys(email)
driver.find_element("id", "password").send_keys(password)
driver.find_element("id", "login-button").click()
The same function can be reused in many test cases.
Reusable functions make an automation framework easier to maintain.
Collections help organize test information.
A list may store test users:
test_users = [
"[email protected]",
"[email protected]",
"[email protected]"
]
A dictionary may store login information:
test_account = {
"email": "[email protected]",
"password": "SecurePassword123"
}
Collections are especially useful in data-driven testing.
Object-oriented programming helps organize larger automation projects.
A class may represent a webpage:
class LoginPage:
def __init__(self, driver):
self.driver = driver
def enter_email(self, email):
self.driver.find_element("id", "email").send_keys(email)
def enter_password(self, password):
self.driver.find_element("id", "password").send_keys(password)
def click_login(self):
self.driver.find_element("id", "login-button").click()
This approach supports the Page Object Model, a common automation design pattern.
Object-oriented programming can improve:
Automation scripts may encounter unexpected conditions.
Examples include:
Python exception handling allows scripts to respond safely:
try:
login_button = driver.find_element("id", "login-button")
login_button.click()
except Exception as error:
print(f"Login test failed: {error}")
Professional frameworks should also log errors and collect evidence such as screenshots.
Automation projects may use files for:
Python file handling allows scripts to read and write this information.
Example:
with open("test-results.txt", "a", encoding="utf-8") as file:
file.write("Login test passed\n")
Estimated duration: 13 hours
The second course focuses on practical browser automation across multiple browsers and operating systems.
Topics include:
Selenium WebDriver can control supported browsers such as:
A browser session may include:
Example:
from selenium import webdriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.get("https://example.com")
print(driver.current_url)
print(driver.title)
driver.quit()
Selenium must identify webpage elements before interacting with them.
Common locator strategies include:
Example:
email_field = driver.find_element("id", "email")
email_field.send_keys("[email protected]")
Choosing stable locators is important because fragile selectors can make tests unreliable.
XPath can locate elements based on their position, attributes, text, or relationship to other elements.
Examples:
driver.find_element("xpath", "//button[@type='submit']")
driver.find_element("xpath", "//a[contains(text(), 'Forgot Password')]")
XPath is powerful, especially when elements do not have unique IDs.
However, selectors should remain readable and avoid depending excessively on page position.
CSS selectors provide another flexible way to locate elements.
Examples:
driver.find_element("css selector", "input[name='email']")
driver.find_element("css selector", ".login-form button[type='submit']")
CSS selectors can be concise and efficient.
Some elements change their IDs, classes, location, or content whenever a page loads.
Dynamic applications may also load content after the initial page appears.
Automation scripts must account for:
Reliable tests use stable selectors and appropriate waiting strategies.
An implicit wait tells Selenium to wait for a period when searching for an element.
driver.implicitly_wait(10)
This can reduce immediate failures when pages take a short time to load.
However, implicit waits apply globally and may be less precise than explicit waits.
Explicit waits pause until a specific condition becomes true.
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 10)
login_button = wait.until(
EC.element_to_be_clickable((By.ID, "login-button"))
)
login_button.click()
Explicit waits can check whether an element is:
They are usually more reliable than fixed delays.
Using time.sleep() pauses the script for a fixed period.
Although it may be useful in limited situations, excessive fixed waiting can make tests:
Condition-based waits are generally more efficient.
Selenium can automate:
Example:
from selenium.webdriver.support.ui import Select
country_dropdown = Select(
driver.find_element("id", "country")
)
country_dropdown.select_by_visible_text("United States")
A test should verify both successful submissions and expected validation errors.
Web applications may display browser alerts.
Selenium can accept, dismiss, or read alert text.
alert = driver.switch_to.alert
print(alert.text)
alert.accept()
Tests may verify confirmation messages, warning dialogs, or cancellation behavior.
Some webpage content is displayed inside frames or iframes.
Selenium must switch into the frame before interacting with its content.
driver.switch_to.frame("payment-frame")
After completing the action, return to the main page:
driver.switch_to.default_content()
A test may open another tab or browser window.
Selenium can switch between window handles:
original_window = driver.current_window_handle
for window_handle in driver.window_handles:
if window_handle != original_window:
driver.switch_to.window(window_handle)
break
This is useful for testing:
A website may behave differently in different browsers.
Cross-browser testing checks whether important features work consistently in:
Potential differences include:
Automating these tests can help teams identify compatibility problems before release.
Estimated duration: 14 hours
The final course focuses on creating maintainable automation frameworks and connecting them with professional development workflows.
Topics include:
A few independent test scripts may be manageable.
As the number of tests grows, the project needs structure.
An automation framework can define:
A good framework improves:
The Page Object Model separates webpage interaction from test logic.
A page class contains element locators and page actions.
The test then uses those actions.
class LoginPage:
EMAIL_FIELD = ("id", "email")
PASSWORD_FIELD = ("id", "password")
LOGIN_BUTTON = ("id", "login-button")
def __init__(self, driver):
self.driver = driver
def login(self, email, password):
self.driver.find_element(*self.EMAIL_FIELD).send_keys(email)
self.driver.find_element(*self.PASSWORD_FIELD).send_keys(password)
self.driver.find_element(*self.LOGIN_BUTTON).click()
The test remains simple:
login_page = LoginPage(driver)
login_page.login("[email protected]", "SecurePassword123")
When a page changes, you update the page object instead of every test.
Logging records information about test execution.
A log may capture:
Example:
import logging
logging.basicConfig(
filename="automation.log",
level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(message)s"
)
logging.info("Login test started")
Logs make failures easier to investigate.
Python includes the unittest framework.
A basic test may look like:
import unittest
from selenium import webdriver
class LoginTest(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Chrome()
def test_login_page_title(self):
self.driver.get("https://example.com/login")
self.assertEqual(self.driver.title, "Login")
def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
unittest.main()
Common unittest features include:
Pytest is a popular testing framework that supports concise test syntax and powerful features.
Example:
def test_page_title(driver):
driver.get("https://example.com")
assert driver.title == "Example Domain"
Pytest can support:
Fixtures prepare data or environments before a test.
A fixture can:
Example:
import pytest
from selenium import webdriver
@pytest.fixture
def driver():
browser = webdriver.Chrome()
yield browser
browser.quit()
Data-driven testing runs the same test with different inputs.
For example, a login test can evaluate:
Using Pytest parameterization:
import pytest
@pytest.mark.parametrize(
"email,password",
[
("[email protected]", "ValidPassword"),
("[email protected]", "WrongPassword"),
("", "MissingEmail")
]
)
def test_login(email, password):
print(email, password)
This reduces duplicated test code.
A test suite groups related tests.
Possible suites include:
Organized suites allow teams to run the most appropriate tests for each release.
Version control helps automation teams manage framework changes.
Git and GitHub can be used to:
Never store passwords, API keys, or other secrets directly in a public repository.
Jenkins can automatically run Selenium tests when specific events occur.
A Jenkins pipeline may:
This allows automated testing to become part of the software-delivery process.
Continuous integration involves frequently combining code changes and automatically validating them.
An automation pipeline can run when:
Automated tests provide fast feedback about whether a change has broken existing functionality.
A CI/CD pipeline may include:
UI tests are usually slower than unit tests, so teams often choose a smaller smoke suite for every build and run full regression tests on a schedule.
The specialization includes practical activities that guide learners through building and improving automation frameworks.
Projects may involve:
These projects help turn theoretical concepts into practical automation experience.
The program introduces or uses:
The program may be suitable for:
Manual testers can develop the technical skills needed to move into automation testing.
QA professionals can learn how to create repeatable browser tests and integrate them into release workflows.
The program begins with Python fundamentals and does not require prior automation experience.
Python developers can expand into software testing and browser automation.
Developers can use Selenium to test their applications and reduce regression problems.
Students can add automation-testing projects to their portfolios.
DevOps learners can understand how browser tests connect with Jenkins and CI/CD pipelines.
Freelancers can offer web-testing and automation services to clients.
The complete specialization is not available entirely free.
However, selected Preview lessons may sometimes be available inside an individual course.
Follow these steps:
The Preview option may not be displayed for every course, account, or location.
When Preview is unavailable, check whether the enrollment page offers:
Complete courses, graded assignments, projects, and the certificate may require paid enrollment.
Always review current access and payment terms before confirming.
Do not only watch demonstrations. Recreate every automation example.
Use websites designed for automation practice or applications you have permission to test.
Prefer stable IDs, names, or meaningful attributes over long position-based XPath expressions.
Use explicit waits whenever possible instead of relying on long sleep() commands.
Start with a few reliable tests before adding reports, configuration, parallel execution, and CI/CD.
Publish your framework with a professional README and remove all sensitive information.
Save logs and screenshots when a test fails.
Confirm that your scripts work in Chrome, Firefox, and Edge when relevant.
Automate at least one smoke-test suite through Jenkins.
Include:
Consider building automation frameworks for:
A strong portfolio project could include:
After developing sufficient testing and programming experience, learners may explore roles such as:
Completing the specialization does not guarantee employment.
Employers may also evaluate:
You can check individual courses for selected Preview lessons. Free access is not guaranteed.
No. The program is designed for beginners and starts with foundational Python concepts.
The specialization contains three courses.
The estimated completion time is approximately four weeks at around 10 hours per week.
Yes. The first course covers Python variables, data types, control structures, functions, collections, classes, objects, and reusable code.
Yes. Selenium WebDriver 4 is the primary browser-automation technology used throughout the specialization.
Yes. The second course covers advanced element location using XPath and CSS selectors.
Yes. The curriculum covers synchronization and efficient wait strategies for reliable execution.
Yes. The advanced course covers Pytest and unittest.
Yes. You will learn how to manage test data and run tests with multiple data sets.
Yes. You will learn how to run browser automation across supported browsers and operating systems.
Yes. Version control and GitHub integration are included.
Yes. The final course includes Jenkins and continuous-integration workflows.
No. Preview access generally does not include complete graded work, projects, or the certificate.
Master Python, Selenium WebDriver 4, XPath, CSS selectors, browser automation, Pytest, unittest, logging, data-driven testing, GitHub, Jenkins, cross-browser testing, and CI/CD.
Select an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded projects, and the certificate may require paid enrollment. Financial aid may be available.
Employers and clients want developers who can create responsive interfaces, manage user accounts, store application data, integrate maps and third-party tools, protect private pages, and deploy complete web applications.
The ReactJS 18 and Firebase 9 Realtor Clone Specialization offers a project-based learning path that helps you practise these skills by building a functional real-estate application.
Instead of studying isolated code examples, you will work through the development of a complete realtor platform using ReactJS 18, Firebase 9, Tailwind CSS, OAuth, dynamic listings, user profiles, image sliders, interactive maps, and cloud deployment.
You may be able to start learning free by selecting one of the individual courses and checking whether Preview lessons are currently available.
A real-estate application is an excellent portfolio project because it combines many important web-development features inside one platform.
A professional realtor website may need to support:
Building these features helps you understand how different front-end and cloud technologies work together.
You will not only practise creating pages. You will learn how to connect authentication, user data, application state, reusable components, third-party libraries, and deployment into one complete project.
This is a three-course specialization designed for intermediate developers.
The recommended learning schedule is approximately:
The three courses are:
The learning path begins with project setup and interface development before progressing into authentication, protected profiles, listing management, interactive maps, advanced components, and production deployment.
This program is best suited to learners who already have a basic understanding of:
Previous Firebase experience may be helpful, but it is not required.
Because the program is project-focused, learners should be comfortable reading JavaScript and understanding basic React application structure.
Throughout the specialization, you will learn how to:
Estimated duration: seven hours
The first course introduces the project structure and the main tools used to build the realtor application.
It covers:
React allows developers to build modern interfaces using reusable components.
A component may represent:
Using components helps keep the application organized and reduces repeated code.
A well-structured React application may separate:
This organization becomes especially important as the project grows.
Tailwind CSS is a utility-first styling framework.
Instead of writing a separate CSS rule for every element, developers can combine utility classes directly inside their components.
Tailwind CSS can help you control:
For example:
<button className="rounded-lg bg-blue-600 px-5 py-3 font-semibold text-white hover:bg-blue-700">
View Listing
</button>
This approach can speed up interface development and support consistent styling across the application.
A realtor application should work across:
Responsive design ensures that property cards, images, navigation, forms, and maps adapt to different screen sizes.
You may use Tailwind responsive classes to modify layouts at different breakpoints.
For example:
<div className="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-3">
{/* Property cards */}
</div>
This layout displays one column on smaller screens and more columns on larger screens.
Firebase provides cloud services that can support application authentication, data management, and other back-end functions.
During the project, Firebase is used to manage important application features such as:
Firebase 9 uses a modular approach, allowing developers to import only the services their application needs.
A registration page typically collects information such as:
The application should:
Clear validation and error messages improve the user experience.
Registered users need a secure way to access and exit their accounts.
A login form may:
Logout functionality should end the authenticated session and return the user to a public page.
Password recovery helps users regain access when they forget their passwords.
A typical process includes:
This feature is expected in most professional applications with user accounts.
OAuth allows users to sign in with an existing account from another provider.
Google OAuth can make registration faster because users do not need to create and remember another password.
The application still needs to:
Estimated duration: 10 hours
The second course focuses on protected user profiles and real-estate listing management.
Topics include:
Some pages should only be accessible to authenticated users.
Examples include:
A private route checks whether the visitor is authenticated before displaying protected content.
When the user is not signed in, the application can redirect them to the login page.
Protected routes improve application security and prevent unauthorized access to account-specific features.
A user profile may display:
A dynamic profile allows the user to update information without creating a new account.
The application should validate profile changes and synchronize them with the stored user information.
Many cloud operations require time to complete.
Examples include:
A loading spinner shows users that the application is processing their request.
This is better than leaving the page unchanged, which may make users think the application has stopped working.
A property-listing form may collect:
The application should validate required fields before saving the listing.
A clear form structure reduces errors and helps users complete the process successfully.
Real-estate websites depend heavily on visual content.
Property listings may include several images that help potential buyers or renters evaluate the property.
The application should manage:
Optimized images improve page speed and provide a better browsing experience.
The user profile can display all properties created by the authenticated user.
Each listing may provide actions such as:
This section helps users manage their property portfolio from one location.
The Edit Listing page allows users to update existing property information.
The application must:
Ownership checks are important because users should not be able to modify another person’s listings.
Estimated duration: seven hours
The final course enhances the application with interactive features and prepares it for public deployment.
Topics include:
An image slider allows users to browse multiple property photographs.
A professional slider may include:
Swiper can be used to create interactive image galleries for property listings.
Sharing tools make it easier for visitors to send a property listing to another person.
A share feature may allow users to:
A small feature like this can significantly improve usability.
Interested users need a way to contact the person responsible for a listing.
A landlord contact component may display:
The message can automatically include the listing name to make the inquiry clearer.
Maps provide important location context for property listings.
Leaflet can be used to display:
A listing page can display a map marker based on the stored geographic coordinates.
Maps help users understand the surrounding area and compare properties by location.
A realtor homepage can highlight:
Dynamic content keeps the homepage updated as new properties are added.
Instead of manually editing the homepage, the application can retrieve the latest listing information from the database.
Deployment makes the application publicly accessible.
Before deployment, you should:
Vercel can host the completed React application and provide a public project URL.
The central project is a full-featured realtor application built with ReactJS, Firebase, and Tailwind CSS.
Your completed project can demonstrate your ability to:
This makes the project valuable for a professional development portfolio.
The specialization introduces or uses:
The program may be useful for:
Developers can strengthen their ability to create complete project-based applications.
Front-end developers can gain experience with authentication, dynamic data, maps, and deployment.
JavaScript developers can practise using React in a realistic application.
Firebase provides practical exposure to authentication and cloud data services without requiring a traditional custom server.
Freelancers can use the project structure to develop real-estate websites or similar client applications.
Students can add a detailed React project to their portfolio.
Entrepreneurs can better understand how marketplace and listing platforms are developed.
The complete specialization is not officially available entirely free.
However, individual courses may sometimes display selected Preview lessons.
Follow these steps:
The Preview option may not appear for every learner or course.
When Preview is unavailable, check whether the enrollment page offers:
Complete courses, graded activities, projects, and the certificate may require paid enrollment.
Always review the current payment terms before confirming.
Do not only watch the instructor. Create the project in your own development environment.
Use clear commits as you complete authentication, profiles, listings, maps, and deployment.
Change the branding, layout, colors, homepage, and property fields so your portfolio does not look identical to the guided version.
Consider adding:
Review registration, login, logout, password recovery, OAuth, and protected routes.
Add labels, keyboard support, descriptive buttons, clear errors, and alternative image text.
Compress property images and avoid uploading unnecessarily large files.
A professional README should include:
After developing sufficient experience and building additional projects, learners may explore roles such as:
Completing the specialization does not guarantee employment.
Employers may also evaluate:
You can check the individual courses for selected Preview lessons. Free access is not guaranteed.
It is classified as intermediate level. Basic JavaScript and React knowledge is recommended.
The specialization contains three courses.
The listed estimate is approximately four weeks at around 10 hours per week.
Yes. ReactJS 18 is the main front-end technology used throughout the project.
Yes. Firebase 9 is used for authentication and application data.
Yes. Tailwind CSS is used to style the responsive application interface.
Yes. The project includes OAuth authentication.
Yes. You will learn how to protect profile and account-specific pages.
Yes. You will create, display, edit, and manage property listings.
Yes. Leaflet maps are integrated into the realtor application.
Yes. The finished application is deployed to Vercel.
No. Preview access generally does not include the complete graded experience or certificate.
Master ReactJS 18, Firebase 9, Tailwind CSS, authentication, Google OAuth, protected routes, property listings, image sliders, Leaflet maps, responsive design, and Vercel deployment.
Select an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded projects, and the certificate may require paid enrollment. Financial aid may be available.
Online stores use databases to manage customers, products, orders, and payments. Business applications store employee information, transactions, reports, and operational records. Mobile applications retrieve profiles, messages, preferences, and activity history from databases.
Behind these systems are developers, analysts, and database professionals who understand how to organize, query, secure, and scale information.
The PostgreSQL for Everybody Specialization provides a structured learning path for people who want to progress from foundational SQL and database design to advanced PostgreSQL features, text processing, JSON, search indexing, database architecture, and NoSQL systems.
You may be able to start learning free by opening an individual course and checking whether selected Preview lessons are currently available.
The program combines theory with hands-on assignments involving table creation, data manipulation, advanced queries, normalization, regular expressions, text indexing, JSON, API data, stored procedures, database architecture, and scalable data storage.
PostgreSQL is a powerful open-source relational database-management system used to store, organize, retrieve, and process structured information.
Developers and organizations use PostgreSQL for:
Learning PostgreSQL can help you understand not only how to write SQL queries, but also how professional database systems are designed and maintained.
PostgreSQL supports features such as:
These capabilities make PostgreSQL useful for both traditional relational applications and modern data-driven services.
PostgreSQL for Everybody is a four-course specialization designed for learners with some previous programming experience.
The program is classified as intermediate level.
Basic Python knowledge is recommended because parts of the specialization use Python when retrieving API data and working with PostgreSQL and JSON.
The estimated learning schedule is approximately:
The courses should ideally be completed in order because later topics build on earlier database and SQL concepts.
The four courses are:
Together, they cover PostgreSQL from basic relational design through advanced search, NoSQL, scalability, and database architecture.
Throughout the specialization, you will learn how to:
psql command-line environmentEstimated duration: 14 hours
The first course introduces the foundations of relational databases and PostgreSQL.
It focuses on practical SQL operations, table design, keys, relationships, and the history and principles behind relational database systems.
You will learn how to:
psqlCRUD represents four fundamental database operations:
Add new information to a database.
INSERT INTO customers (name, email)
VALUES ('Alex Smith', '[email protected]');
Retrieve stored information.
SELECT name, email
FROM customers;
Modify an existing record.
UPDATE customers
SET email = '[email protected]'
WHERE customer_id = 10;
Remove a record.
DELETE FROM customers
WHERE customer_id = 10;
Nearly every database-driven application depends on these operations.
A table organizes information into rows and columns.
A customer table might include:
Example:
CREATE TABLE customers (
customer_id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
email VARCHAR(150) UNIQUE,
account_status VARCHAR(30),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
A well-designed table should use appropriate data types, constraints, and identifiers.
A primary key uniquely identifies each row in a table.
For example, two customers may have the same name, but they should not have the same customer ID.
Primary keys help databases:
A foreign key creates a relationship between tables.
For example, an orders table may contain a customer ID that connects each order to the correct customer.
CREATE TABLE orders (
order_id SERIAL PRIMARY KEY,
customer_id INTEGER REFERENCES customers(customer_id),
order_date DATE,
total_amount NUMERIC(10,2)
);
Foreign keys help ensure that related information remains valid.
A one-to-many relationship occurs when one record relates to several records in another table.
Examples include:
This is one of the most common database relationships.
A many-to-many relationship occurs when records from both tables can connect to several records in the other table.
Examples include:
A junction table is normally used to represent the relationship.
For example:
CREATE TABLE student_courses (
student_id INTEGER REFERENCES students(student_id),
course_id INTEGER REFERENCES courses(course_id),
PRIMARY KEY (student_id, course_id)
);
Data integrity means keeping information accurate, valid, and consistent.
PostgreSQL supports integrity through:
Strong database design reduces invalid records and makes applications more reliable.
Estimated duration: 16 hours
The second course develops more advanced SQL and PostgreSQL skills.
It covers:
Real-world data is often stored in spreadsheets or CSV files.
Imported data may include:
Normalization reorganizes the data into a cleaner relational structure.
For example, instead of repeating customer information in every order record, customer details can be stored once in a customer table and referenced through a customer ID.
This can improve:
Normalization is the process of organizing data to reduce duplication and improve integrity.
A normalized design commonly separates different types of information into related tables.
For example, an online store may use:
Rather than storing all information in one large table, each table has a clear responsibility.
Databases frequently store text such as:
PostgreSQL provides functions for:
Text-processing skills are especially useful when working with inconsistent external data.
Applications use dates for:
PostgreSQL supports date and time data types and functions that allow developers to:
A stored procedure is reusable database logic stored within the database system.
Stored procedures can:
They can be useful when an operation must be executed consistently by several applications.
Regular expressions allow developers to find text matching specific patterns.
They can be used to:
For example, a query may identify records containing a hashtag or a specific text format.
Regular expressions are powerful, but complex patterns should be documented clearly.
A transaction groups several database operations into one controlled process.
For example, transferring funds may involve:
If one step fails, the database may need to reverse the entire operation.
Transactions help protect data consistency.
Estimated duration: 16 hours
The third course explores how PostgreSQL can store, index, and retrieve modern data formats.
It combines:
JSON is widely used by web services and APIs.
Example:
{
"customer_id": 125,
"name": "Alex Smith",
"interests": ["databases", "python", "analytics"]
}
PostgreSQL can store JSON documents while still providing relational database capabilities.
This allows developers to work with flexible data when every record may not have exactly the same structure.
Relational tables are ideal when information has a clear, consistent structure.
JSON can be useful when:
Developers should choose the model that fits the application rather than using JSON for every problem.
APIs provide information to applications through structured requests and responses.
A developer may use Python to:
This workflow is common in:
PostgreSQL includes advanced full-text search capabilities.
Developers can:
Applications that may benefit from text search include:
GIN stands for Generalized Inverted Index.
GIN indexes can improve searches involving:
An inverted index maps values or words to the records that contain them.
This is similar to how a book index maps topics to page numbers.
Using an index can make repeated searches significantly faster.
tsvector for Full-Text SearchPostgreSQL can convert text into a searchable tsvector representation.
The database can then match search queries against indexed text.
This supports features such as:
These features allow PostgreSQL to support search functionality that might otherwise require a separate search service for smaller or moderately sized applications.
The course includes practical work involving text indexing and retrieval.
A simplified search workflow may involve:
This introduces important concepts used in search engines, text mining, and information retrieval.
Estimated duration: 11 hours
The final course explores database architecture and scalable data-storage approaches.
It covers:
Database architecture describes how a database system stores data, processes queries, manages connections, and protects transactions.
Important architectural concepts may include:
Understanding architecture helps developers design applications that use the database effectively.
SQL databases generally use:
NoSQL systems may use:
Neither approach is automatically better.
The correct choice depends on:
ACID describes important transaction properties:
A transaction is completed fully or not at all.
A transaction moves the database from one valid state to another.
Concurrent transactions should not interfere with one another incorrectly.
Committed information remains stored even after a failure.
ACID is important for systems such as banking, orders, inventory, and financial transactions.
BASE is commonly associated with distributed NoSQL systems.
It represents:
In eventual-consistency systems, data across distributed nodes may not update at exactly the same moment, but it becomes consistent over time.
This may be acceptable for certain large-scale applications where availability and distribution are prioritized.
Deno KV is a key-value data store associated with the Deno runtime.
Key-value systems store information using a unique key and its corresponding value.
They can be useful for:
The course uses Deno KV to demonstrate NoSQL indexing and scalable database concepts.
Scalability refers to the ability of a system to handle increasing data, users, and requests.
Database scalability may involve:
A scalable architecture should be chosen according to the real requirements of the application.
The specialization uses a custom autograding environment for practical assignments.
Hands-on activities include:
Practical database work is essential because SQL skills improve through writing, testing, and correcting real queries.
After completing the program and practising independently, you can develop knowledge in:
The program may be useful for:
Learners can develop practical PostgreSQL and SQL knowledge.
Back-end developers frequently need to create data models, queries, indexes, and database integrations.
SQL skills help analysts retrieve, filter, combine, and transform business information.
The program introduces API ingestion, text data, JSON, database architecture, and scalable storage.
Python developers can learn how to connect applications and scripts with PostgreSQL.
Full-stack developers benefit from understanding the database layer behind web applications.
Students can strengthen their understanding of relational design, transactions, indexing, and data architecture.
Support teams can use database knowledge to diagnose data, query, and performance issues.
The program is classified as intermediate level.
Learners should ideally understand:
Previous SQL experience can be helpful but is not required for every topic because the first course introduces basic SQL and database design.
The complete specialization is not available entirely free.
However, individual courses may sometimes offer selected Preview lessons.
Follow these steps:
The Preview option may not appear.
When Preview is unavailable, check whether the enrollment page provides:
The full specialization, assignments, graded activities, and certificate may require paid enrollment.
Always review the current enrollment and payment conditions before confirming.
Write queries instead of only reading examples.
Create a database for a realistic project such as:
Identify:
Practise cleaning and normalizing CSV files.
Use:
Measure query performance before and after indexing.
Store API responses and compare JSON queries with relational designs.
Practise full-text search and ranking.
Include an entity-relationship diagram, schema explanation, sample queries, and setup instructions.
Consider building:
A strong portfolio project could include:
After developing sufficient PostgreSQL, SQL, and database skills, learners may explore roles such as:
Completing the specialization does not guarantee employment.
Employers may also evaluate:
You can check individual courses for selected Preview lessons. Free access is not guaranteed.
The specialization is classified as intermediate. Basic Python knowledge is recommended.
The program contains four courses.
The listed estimate is approximately four weeks at around 10 hours per week.
Yes. It covers SQL from basic CRUD operations through advanced querying and database architecture.
Yes. PostgreSQL is the main database platform used throughout the program.
Yes. You will learn primary keys, foreign keys, one-to-many relationships, and many-to-many relationships.
Yes. Stored procedures are included in the intermediate PostgreSQL course.
Yes. You will retrieve API data, work with JSON, and store it in PostgreSQL.
Yes. You will use PostgreSQL indexes and build search capabilities.
Yes. The final course compares SQL and NoSQL and introduces Deno KV.
No. Preview access generally does not include the complete graded experience or certificate.
Learn PostgreSQL, SQL, database design, CRUD operations, normalization, stored procedures, JSON, Python integration, full-text search, NoSQL, database architecture, and scalability.
Select an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded assignments, projects, and the certificate may require paid enrollment. Financial aid may be available.
HTML creates the structure of a webpage, while CSS controls its appearance, layout, responsiveness, typography, animations, and visual presentation.
Together, these technologies power landing pages, business websites, online portfolios, product pages, blogs, dashboards, forms, and modern web applications.
The Modern HTML & CSS From the Beginning 2.0 Specialization provides a structured learning path for beginners who want to build attractive, accessible, responsive, and professionally organized websites.
You may be able to start learning free by opening one of the individual courses and checking whether selected Preview lessons are available.
The program takes you from basic HTML documents and CSS styling to advanced layouts, responsive design, animations, transitions, JavaScript-powered interactions, version control, deployment, and portfolio-ready projects.
HTML and CSS remain the foundation of front-end web development.
Even developers who later learn JavaScript frameworks, mobile development, back-end programming, or full-stack development still need a strong understanding of webpage structure and styling.
HTML and CSS skills can help you:
Learning these technologies from the beginning gives you the confidence to create websites without depending entirely on premade themes or page builders.
Modern HTML & CSS From the Beginning 2.0 is a beginner-friendly specialization consisting of three courses.
The program is designed to be completed in approximately four weeks when studying around 10 hours per week.
It follows a flexible, self-paced structure, allowing you to learn according to your own schedule.
No previous professional web-development experience is required.
The three courses are:
The learning path begins with the fundamentals and gradually introduces more advanced design, layout, responsiveness, accessibility, animation, organization, and deployment techniques.
Throughout the program, you will learn how to:
Estimated duration: 11 hours
The first course introduces the essential building blocks of webpage development.
You will learn how HTML documents are structured and how CSS transforms basic content into a visually organized website.
Topics include:
Every HTML webpage follows a structured format.
A basic document includes information such as:
Example:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>My Professional Website</title>
<link rel="stylesheet" href="style.css">
</head>
<body>
<h1>Welcome to My Website</h1>
<p>This is my first modern webpage.</p>
</body>
</html>
Understanding this structure is essential because every webpage depends on it.
Semantic HTML uses elements that clearly describe the purpose of the content.
Examples include:
headernavmainsectionarticleasidefooterSemantic structure can improve:
A clearly structured webpage is easier for both users and assistive technologies to navigate.
Links connect pages and resources.
Images add visual information.
Lists organize related content.
You can use these elements to create:
Each image should include useful alternative text when it communicates meaningful information.
Example:
<img
src="responsive-design.jpg"
alt="Responsive website displayed on desktop, tablet, and mobile screens"
>
Forms allow users to interact with a website.
They are commonly used for:
A professional form should include:
Example:
<form>
<label for="email">Email Address</label>
<input
type="email"
id="email"
name="email"
required
>
<button type="submit">Subscribe</button>
</form>
CSS determines how HTML elements appear.
A CSS rule includes a selector and one or more declarations.
Example:
body {
font-family: Arial, sans-serif;
line-height: 1.6;
color: #1f2937;
background-color: #ffffff;
}
You can use CSS to control:
Every HTML element can be viewed as a rectangular box.
The CSS box model includes:
Understanding the box model helps you control element size and spacing.
Example:
.card {
width: 320px;
padding: 24px;
border: 1px solid #d0d5dd;
margin: 20px;
}
Many layout problems become easier to solve once you understand how these layers work together.
Flexbox is a layout system designed for arranging elements along one main direction.
It is useful for:
Example:
.features {
display: flex;
gap: 24px;
justify-content: center;
align-items: stretch;
flex-wrap: wrap;
}
Flexbox helps developers create layouts that adjust more naturally to different screen sizes.
Estimated duration: 12 hours
The second course moves beyond foundational styling and focuses on professional responsive layouts.
Topics include:
Advanced Flexbox techniques allow you to control:
These features are especially useful when designing layouts that must adapt across many devices.
CSS Grid is designed for layouts that involve both rows and columns.
It can be used for:
Example:
.projects-grid {
display: grid;
grid-template-columns: repeat(3, 1fr);
gap: 24px;
}
A responsive version may use:
.projects-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
gap: 24px;
}
This automatically adjusts the number of columns according to available space.
Media queries apply styles when specific screen conditions are met.
Example:
@media (max-width: 768px) {
.hero {
flex-direction: column;
text-align: center;
}
}
Media queries can help you change:
They are an essential part of responsive web design.
Media queries respond to the viewport size.
Container queries respond to the size of a specific parent container.
This allows reusable components to adapt according to where they are placed.
For example, the same product card can use one layout inside a wide content area and another layout inside a narrow sidebar.
Container queries support more flexible component-based design.
Typography should remain readable across screen sizes.
The program introduces units such as:
rememvwvhYou can also use clamp() to create fluid text sizes.
Example:
h1 {
font-size: clamp(2rem, 5vw, 4.5rem);
}
This allows the heading to grow smoothly without becoming too small or too large.
Mobile-first design begins with styles for smaller screens and then adds enhancements for larger displays.
Example:
.course-card {
display: block;
}
@media (min-width: 768px) {
.course-card {
display: flex;
}
}
This approach encourages developers to focus on:
A website may behave differently across browsers.
You should test projects in multiple environments and review:
Browser developer tools can help identify these issues.
Version control helps you manage and publish your work.
Git allows you to track changes, while GitHub provides an online home for your repositories.
You can use these tools to:
Deployment makes your website accessible online.
Before deployment, confirm that:
A live website is more valuable in a portfolio than screenshots alone.
Estimated duration: 11 hours
The final course focuses on creating polished, interactive, and portfolio-ready projects.
Topics include:
Transitions create smooth visual changes between element states.
Example:
.button {
background-color: #175cd3;
transform: translateY(0);
transition: background-color 0.25s ease, transform 0.25s ease;
}
.button:hover {
background-color: #004eeb;
transform: translateY(-3px);
}
Transitions can improve:
They should support usability rather than distract users.
Keyframe animations allow more complex movement and visual effects.
Example:
@keyframes fade-in-up {
from {
opacity: 0;
transform: translateY(24px);
}
to {
opacity: 1;
transform: translateY(0);
}
}
.hero-content {
animation: fade-in-up 0.7s ease forwards;
}
Animations may be used for:
Always consider reduced-motion preferences for users who may experience discomfort from animation.
JavaScript can add or remove CSS classes in response to user actions.
Example:
const menuButton = document.querySelector(".menu-button");
const navigation = document.querySelector(".navigation");
menuButton.addEventListener("click", () => {
navigation.classList.toggle("navigation--open");
});
This approach can create:
BEM stands for:
It is a naming methodology that helps organize CSS.
Example:
.card {}
.card__title {}
.card__description {}
.card--featured {}
BEM can improve:
This becomes increasingly valuable as a project grows.
The specialization includes practical projects that help reinforce your skills.
Examples include:
These projects allow you to practise:
By the end of the program, you can have several websites ready to include in a portfolio.
Use your new skills to create original projects such as:
A strong project should demonstrate:
This program may be suitable for:
No previous professional coding experience is required.
The program builds the HTML and CSS foundation needed for more advanced front-end development.
Freelancers can learn how to create landing pages, portfolios, and business websites for clients.
UI and graphic designers can strengthen their ability to turn designs into functioning webpages.
Entrepreneurs can learn how to create and customize websites for their businesses.
Marketers can improve their ability to edit landing pages, forms, campaign pages, and website content.
Students can build portfolio projects while developing practical web-development skills.
WordPress users can improve their ability to customize themes, page layouts, forms, and responsive styles.
The full specialization is not officially available entirely free.
However, an individual course may sometimes display selected Preview lessons.
Follow these steps to check:
The Preview option may not be displayed.
When Preview is unavailable, review the enrollment page for:
The complete courses, graded work, projects, and certificate may require paid enrollment.
Always review the current payment terms before confirming.
Do not only watch the videos. Write the HTML and CSS yourself.
After completing a guided project, rebuild it using your own structure and design.
Test every project on desktop, tablet, and mobile layouts.
Choose elements according to their purpose rather than using generic containers for everything.
Group related styles, use consistent naming, and avoid unnecessary duplication.
Review labels, keyboard navigation, heading structure, contrast, and alternative text.
Publish each project with a clear README file.
A live website gives employers and clients a better way to evaluate your skills.
Include at least three polished projects showing different layouts and design styles.
After building sufficient skills and a professional portfolio, learners may explore opportunities such as:
Completing the specialization does not guarantee employment.
Employers and clients may also evaluate:
You can check the individual courses for selected Preview lessons. Free access is not guaranteed.
Yes. It is classified as beginner level and does not require previous professional experience.
The specialization contains three courses.
The estimated completion time is approximately four weeks at around 10 hours per week.
Yes. It covers HTML structure, tags, attributes, forms, semantic elements, and accessibility.
Yes. CSS is the central focus of the program.
Yes. The specialization covers both layout systems.
Yes. It covers media queries, container queries, mobile-friendly layouts, and responsive typography.
Yes. The third course covers transitions, keyframes, and interactive animation techniques.
It includes JavaScript integration for dynamic interface elements, but it is primarily an HTML and CSS program.
Yes. Version control, GitHub, and deployment are included.
Yes. Projects include a pricing grid, landing form, Lumina Creative, Tutor, and responsive animated websites.
No. Preview access generally does not include the complete graded experience or certificate.
Master semantic HTML, modern CSS, forms, Flexbox, CSS Grid, media queries, container queries, responsive typography, accessibility, animations, GitHub, and real-world web projects.
Open an individual course and check whether Preview is available. Free preview access is not guaranteed. Complete courses, graded work, projects, and the certificate may require paid enrollment. Financial aid may be available.