#APIs
48 articles tagged with #APIs
Project: Build a Full-Stack To-Do App with React, Node.js and MongoDB
A full-stack to-do app is the perfect first MERN project — it covers every concept you'll use in production: REST APIs, database CRUD operations, JWT authentication, and deploying a frontend and backend separately. Build it once, understand the full stack.
Project: Build a REST API with Python and FastAPI
FastAPI is the fastest-growing Python web framework — and for good reason. In this hands-on project you'll build a fully functional REST API with auto-generated documentation, database persistence, and deployment on Render, all in a single afternoon.
Learn JavaScript Through Music: Build a Playlist App
Building a music player is one of the best JavaScript projects for beginners — it covers DOM manipulation, event listeners, the Fetch API, and the Web Audio element in a context that's genuinely fun. By the end you'll have a working Spotify-style playlist app you can embed anywhere.
Async Python: asyncio Explained for Beginners
Async Python lets a single thread handle hundreds of concurrent I/O operations — making it essential for web APIs, database calls, and AI integrations. This guide explains coroutines, the event loop, await, gather, and real patterns you'll use in FastAPI, httpx, and LLM streaming.
Learn Node.js Through Building a Music API
Node.js is JavaScript on the server, and building a REST API for your music collection is the perfect first project. This guide covers Express routes, middleware, JSON responses, and deploying to a free hosting service — all by building an API for a music playlist.
Building Your First AI-Powered App with the Anthropic API
The fastest way to understand AI engineering is to build something real. This project- based guide walks you through building a writing assistant powered by Claude — from your first API call through streaming responses, a FastAPI backend, a simple frontend, and deployment.
Matplotlib and Seaborn: Data Visualisation in Python
The best data insight is worthless if no one understands the chart. This guide covers matplotlib's core API, Seaborn's statistical plots, best practices for clear design, and how to produce publication-quality figures — from first plot to polished dashboard chart.
Learn React Through Building a Gaming Leaderboard
Gaming leaderboards are the perfect React learning project: they need real-time state updates, list rendering, sorting, filtering, forms, and optional API fetching. This guide teaches core React through building a fully functional leaderboard for your favourite game.
Function Calling and Tool Use in LLMs
Function calling lets a language model request real actions like API calls or database lookups, turning a text generator into a system that gets things done.
REST APIs Explained: How the Web Talks
A REST API is a set of rules that lets programs exchange data over HTTP using URLs and standard verbs. Learn how requests, responses, and resources work.
Getting Started With scikit-learn
scikit-learn is the standard Python library for classic machine learning. Learn its consistent API, core workflow, and how to train your first model correctly.
How to Build a Chatbot With an LLM API
Build a chatbot by calling an LLM API with a system prompt and message history, streaming responses, managing context, and adding tools for real capabilities.
Open Source vs Closed Source AI Models Compared
Open source AI models offer control, privacy, and customization you self-host, while closed source models offer top performance and ease via a managed API.
Building REST APIs With Node.js and Express
Build a REST API with Node.js and Express by defining routes, handling JSON, and returning proper status codes. Here is how to structure one from scratch.
Understanding APIs: A Beginner Friendly Guide
An API is a contract that lets two programs talk to each other. Learn what APIs are, how REST APIs work, and how to make your first request in plain terms.
Build a REST API With FastAPI: A Complete Project
Build a REST API with FastAPI using path operations, Pydantic models, and a database. This complete project covers CRUD, validation, and automatic docs.
Build a Chatbot With Python: Step-by-Step
Build a chatbot with Python by choosing rule-based or LLM-powered logic, handling user input in a loop, and connecting an API like OpenAI for real conversations.
What Is a Token and How Pricing Works for LLMs
A token is the sub-word unit LLMs read and write, and API pricing is charged per token for both input and output. Learn to estimate and control your costs.
How to Cut Your LLM API Costs
Cut LLM API costs by trimming prompts, caching, routing to smaller models, and capping output. Here are the highest-impact tactics for lowering your bill.
JavaScript Fetch API and Working With APIs
The Fetch API is the built-in browser tool for calling web APIs with promises. Learn to make GET and POST requests, handle JSON, and catch errors cleanly.
React useContext and Context API Explained
The Context API shares state across a React tree without prop drilling, and useContext reads it. Learn when to use context and how to avoid its pitfalls.
How to Fetch Data in React With useEffect
Fetch data in React by calling your API inside useEffect, tracking loading and error state, and cleaning up to avoid updates on unmounted components safely.
Building a CRUD API With Node.js
A CRUD API exposes create, read, update, and delete over HTTP. This guide builds one with Node.js and Express, mapping each operation to a REST endpoint.
What Is an API Gateway Explained
An API gateway is the single front door to your backend services, handling routing, auth, and rate limiting. Learn what it does and when your system needs one.
Build a Movie Search App With an API
Build a movie search app that queries a public film API, fetches results with the browser fetch API, and renders posters and details. Learn async requests, state, and API keys.
Build a REST API With Django REST Framework
Build a REST API with Django REST Framework: define models, serializers, and viewsets, then wire routers to expose CRUD endpoints with authentication, pagination, and browsable docs.
Build a Weather Data Analysis Project
Build a weather data analysis project in Python: pull data from an API, wrangle the time series, and visualize temperature and climate trends with clear, honest charts.
Build a React Chatbot with the OpenAI API
Build a React chatbot with the OpenAI API using a backend proxy, streaming responses, and conversation state — full step-by-step walkthrough.
What Is Management? Core Functions Every Leader Uses
Management is the process of planning, organizing, leading, and controlling resources to achieve a defined goal. This guide covers the core functions of management, common styles, and the skills that separate effective managers from the rest.
What Is a Unique Identifier and Why It Matters
A unique identifier is a value guaranteed to distinguish one record from every other in a system, forming the backbone of databases and APIs. This guide explains common types and how to choose the right one.
What Is PySpark? Python's Gateway to Big Data
PySpark is the Python API for Apache Spark, letting developers process massive datasets across many machines using familiar Python syntax. This guide covers what PySpark does, its core components, and when to reach for it.
The ChatGPT API Explained: How to Use It
The ChatGPT API lets developers send conversation messages to a language model and receive generated responses programmatically. This guide covers how the API works, core parameters, and common use cases.
API Design Principles: Resources, Contracts, Versioning
An API is a contract you will be held to long after the code behind it is rewritten, so design decisions about resources, errors, pagination and versioning outlive almost everything else you build. This guide covers the choices that determine whether clients break when you change things.
AI Coding Assistants at Work: Workflow, Review and Limits
AI coding assistants pay off on well-specified, pattern-heavy work and cost you time on novel design. This guide places them precisely in the development loop, gives you a review order that catches machine-specific defects, and names the failure modes — hallucinated APIs, silent context truncation, leaked secrets — you need to watch for.
TensorFlow and Keras: How the Two Fit Together
Keras is the model-building API and TensorFlow is the tensor runtime beneath it. Learn which layer each task belongs in — models and callbacks in Keras, data pipelines and graph compilation in TensorFlow — so shape errors, retracing surprises and deployment questions stop being confusing.
How Kubernetes Works: Control Plane, Nodes, and Scheduling
Kubernetes works by storing your desired state in etcd and running controllers that continuously reconcile reality toward it. Follow one manifest from kubectl apply through the API server, scheduler and kubelet, and almost every cluster behaviour — including the confusing failures — becomes predictable rather than mysterious.
AI Portfolio Projects: Choosing One That Shows Judgment
A strong AI portfolio project is defined by its evaluation and its constraints, not by the model behind it. Choose a task where correctness is measurable, build the harness that measures it, handle the failure cases honestly, and write up what you rejected — that combination is what distinguishes engineering from an API call in a wrapper.
How to Build an MCP Server for Your Internal Tools
Building an MCP server means wrapping internal APIs as named tools with strict input schemas, explicit auth boundaries and error messages a model can act on. This covers choosing what to expose, writing schemas that prevent bad calls, handling credentials, shaping responses for context budgets and testing before an agent touches production.
How to Count Tokens Before You Send an LLM Request
Count tokens locally with the same tokeniser the model uses, before the request leaves your process. This lets you reject or trim oversized inputs, price a call in advance, and reserve headroom for the completion instead of discovering the limit through a truncated answer or a hard API error.
Keras Sequential vs Functional vs subclassing: which API to use
Pick the API from the shape of your model's graph, not from style preference. Sequential handles a single chain, Functional handles multiple inputs, shared layers and merges while staying inspectable and easy to save, and subclassing is for genuinely dynamic forward logic.
Cursor vs offset pagination in REST APIs
Choose pagination by asking one question: can rows appear in the middle of your sort order while a client is paging? If yes, offset will skip and duplicate rows and you need a cursor. This article covers building stable cursors, encoding them, and migrating an existing endpoint.
How to design API error responses with problem details
Give every error in your API one shape that tells a client three things: which class of failure it is, what specifically was wrong, and whether retrying could help. This article covers the problem details fields, stable error types, field-level validation and what must never leak.
How to implement idempotency keys in a REST API
Make retried POST requests safe on the server rather than hoping clients behave. You will learn what record to store against an idempotency key, how to replay a recorded response, how to survive two concurrent retries of the same key, and how long keys should live.
How to test Python code that calls external APIs
Tests that hit a real third-party service are neither fast nor deterministic, and hand-written stubs quietly drift from reality. The workable answer is layered: stub the transport for logic, keep recorded responses for shape, and run one small contract check against the live service on its own schedule.
How to version a REST API without breaking clients
Most API changes do not need a version. Classify each change as additive or breaking first, reserve explicit versioning for the genuine breaks, and run a deprecation process with dates and telemetry behind it rather than an announcement and hope.
React useEffect: when you actually need it
An effect is correct only when it synchronises React with something outside React. Most effects in real codebases are computing derived values, resetting state on a prop change, or responding to events — each of which has a simpler answer. Here is how to tell them apart and delete the rest safely.
How to review AI-generated code without rubber-stamping it
AI code fails differently from human code: clean style, invented assumptions. Use a review order checking interfaces, invented APIs and edge cases first.
Retries, timeouts and fallbacks for LLM API calls
Naive retries on model calls multiply cost and duplicate side effects. Learn timeout budgets, backoff, idempotency keys and fallback chains that degrade gracefully.