IBM Full Stack Software Developer

Every front end starts with these three languages. You structure content in HTML, style and lay it out in CSS, and make it respond with JavaScript that reads input, changes the page and calls a server.

• Structuring pages with HTML elements
• Styling with CSS selectors and the box model
• Flexible layout and responsive design
• JavaScript variables, functions and objects
• The DOM and handling events
• Fetching data from an API

You build A responsive web page that loads and displays live data from an API.

Code without history is code you cannot safely change. You track work with Git, branch and merge, and use GitHub to share code and review changes with others.

• Repositories, commits and history
• Branching and merging
• Resolving conflicts
• Remotes, forks and pull requests
• Reviewing a teammate’s change
• Writing useful commit messages

You build A repository with a branch, a pull request and a resolved merge conflict.

Interfaces grow complicated fast. React organizes them into components that hold their own state. You build components, pass data between them, handle forms and events, and fetch data from a back end.

• Components, props and JSX
• State and the useState hook
• Effects and fetching data
• Lists, forms and controlled inputs
• Sharing state between components
• Routing between views

You build A React application with several views that reads from and writes to an API.

A front end needs something to talk to. You build servers in Node.js, define routes and middleware in Express, handle asynchronous work correctly, and design a REST API that other code can rely on.

• How Node.js runs JavaScript on a server
• Routes and HTTP methods in Express
• Middleware and error handling
• Callbacks, promises and async functions
• Designing a REST API
• Authentication and protecting routes

You build A REST API in Express with protected routes, consumed by a front end.

Python powers many back ends and AI services. You learn its data structures, functions and file handling by writing programs, then use libraries and REST APIs to fetch and process data.

• Types, variables and control flow
• Lists, dictionaries and comprehensions
• Functions and modules
• Reading and writing files
• Using libraries
• Calling REST APIs from Python

You build A Python program that pulls data from an API and saves a processed result.

Flask turns Python into a web service quickly. You build an application that calls an AI service, test it, check its style, and deploy it to a web server.

• Routes and templates in Flask
• Handling forms and requests
• Calling an AI service from a route
• Unit tests for a Flask app
• Linting and code style
• Deploying the application

You build A Flask web application backed by an AI service, tested and deployed.

Most applications keep data. You design relational tables, query them with SQL, and use Django’s models, migrations and views to build a database-backed application with a styled interface.

• Relational tables, keys and relationships
• Basic SQL queries
• Django models and migrations
• Views, templates and URLs
• The Django admin and forms
• Styling with Bootstrap
• Users and authentication

You build A database-backed Django application with accounts and a styled interface.

An app that works on one machine is not yet an app that works anywhere. You package applications into container images, run them on Kubernetes, scale and update them, and manage the whole thing with OpenShift.

• Containers compared with virtual machines
• Writing a Dockerfile and building an image
• Running and networking containers
• Pods, deployments and services in Kubernetes
• Scaling and rolling updates
• Managing applications with OpenShift

You build A containerized application deployed to a cluster and scaled.

Large applications are often split into small services. You decompose an application by responsibility, connect services through APIs, and move suitable pieces into serverless functions, weighing the trade-offs of each.

• Monoliths and microservices compared
• Splitting by responsibility and data
• Service-to-service communication
• Serverless functions and events
• Failure, retries and timeouts between services
• Choosing the right architecture

You build An application split into two services and one serverless function.

Pull everything together in one application. You combine a React front end, a Node.js and Python back end, a database and containers, then add a pipeline that tests and deploys every change.

• Planning the application and its architecture
• Building the front end and the back end
• Containerizing the services
• Automating tests and deployment with a pipeline
• Publishing the project on GitHub

You build A deployed full stack application with an automated build and test pipeline.

AI tools speed up development when you review what they produce. You use them to write, explain and test code, learn where they mislead, and shape your projects into clear work that others can read and judge.

• Where generative AI helps in development
• Prompting for code, tests and explanations
• Reviewing generated code before using it
• Security and licensing concerns
• Writing project documentation people read
• Explaining your design choices

You build A documented project with AI-assisted changes, each reviewed and explained.