Software
glossary.

Agile is an iterative approach to software development where work is delivered in short cycles (sprints), requirements can evolve based on feedback, and working software is prioritized over comprehensive documentation. The core principle: deliver small increments frequently rather than one large release after months of work.

An API is a set of rules that allows different software systems to communicate with each other. It defines the requests a program can make, how to make them, and the data formats used. APIs power everything from mobile apps fetching data to third-party payment integrations.

REST and GraphQL are the two most common API styles. REST uses standard HTTP methods and is simpler; GraphQL lets clients request exactly the data they need.

B2B (business-to-business) e-commerce is online commerce between businesses rather than consumers. It involves complex requirements like customer-specific pricing tiers, bulk ordering, credit terms, approval workflows, and integration with ERP and inventory systems — features that consumer-facing platforms aren't designed to handle.

CI/CD is a practice where code changes are automatically tested, integrated, and deployed to production. Continuous Integration merges and tests code frequently; Continuous Deployment automatically releases tested changes to users. Together, they reduce bugs, speed up releases, and eliminate manual deployment processes.

A code audit is a systematic, independent review of a software codebase that evaluates code quality, architecture, security, performance, test coverage, and maintainability. It produces a written report with specific findings, severity ratings, and actionable recommendations.

Code audits are valuable before acquiring software, after inheriting a codebase, when performance degrades, or when you suspect technical debt is slowing your team down.

Code review is the practice of having another developer examine code changes before they're merged into the main codebase. It catches bugs, enforces consistency, spreads knowledge across the team, and prevents a single point of failure. Every professional development team uses some form of code review.

The discovery phase is the initial stage of a software project where the team gathers requirements, understands the problem, defines the scope, and produces a plan or technical architecture. It typically includes stakeholder interviews, user research, competitive analysis, and a project brief. Good discovery prevents expensive mistakes later.

Fixed-price development is a billing model where the total project cost is agreed upon before work begins, based on a defined scope. The client knows the exact cost upfront, and the development team absorbs the risk of estimation errors. Works best for well-defined projects with clear requirements.

GraphQL is a query language for APIs that lets clients request exactly the data they need — no more, no less. Unlike REST, where each endpoint returns a fixed data structure, GraphQL uses a single endpoint and lets the client define the response shape. Reduces over-fetching and under-fetching of data.

A headless CMS is a content management system that stores and delivers content through an API, without dictating how that content is displayed. Unlike WordPress or Squarespace, a headless CMS separates content creation from frontend presentation, allowing developers to use any framework to render the content.

Popular headless CMS platforms include Sanity, Contentful, Strapi, and Payload. They're commonly paired with Next.js or other frontend frameworks.

Headless commerce is an e-commerce architecture where the frontend (what customers see) is separated from the backend (commerce engine). The two communicate through APIs, giving businesses full control over the customer experience while keeping order processing, inventory, and payments flexible and scalable.

This decoupling means you can redesign the storefront without touching the commerce logic, or connect the same backend to a website, mobile app, and in-store kiosk simultaneously.

Microservices is an architectural style where an application is built as a collection of small, independent services that each handle one specific business function. Each service runs independently, can be deployed separately, and communicates with others through APIs.

Microservices add operational complexity. For most early-stage products and mid-sized applications, a well-structured monolith is simpler, faster to build, and easier to maintain.

A monolith is a software application built as a single, unified codebase where all components — frontend, backend, database access — are tightly integrated and deployed together. Despite the negative connotation, monoliths are simpler to build, test, and deploy than distributed systems.

Most successful products start as monoliths and only break into microservices when specific scaling needs require it. Premature decomposition is a common mistake.

A Minimum Viable Product is the simplest version of a product that can be released to real users to test whether the core idea solves a real problem. It includes only the essential features needed to validate the hypothesis — nothing more. The goal is to learn fast and cheap, not to build a complete product.

An MVP is not a prototype or a demo. It's a real product that real people use, pay for, or engage with. The "minimum" refers to features, not quality — MVPs should still be well-built.

Next.js is a React framework that adds server-side rendering, file-based routing, API routes, and deployment optimization on top of React. It lets developers build full-stack web applications with a single framework instead of stitching together separate tools for the frontend, backend, and routing. Created by Vercel.

Node.js is a JavaScript runtime that allows developers to run JavaScript on the server side, outside of a browser. It's the foundation for most modern JavaScript backends, enabling the same language across frontend and backend. Known for its non-blocking I/O model, which makes it efficient for handling many simultaneous connections.

PostgreSQL is an open-source relational database known for reliability, advanced features, and standards compliance. It supports complex queries, JSON data, full-text search, and geospatial data. It's the default database choice for production applications that need strong data integrity and scalability.

React is a JavaScript library for building user interfaces, created by Meta (Facebook). It uses a component-based architecture where UIs are built from reusable, composable pieces. React handles the view layer and is commonly paired with frameworks like Next.js for routing, server rendering, and deployment.

REST (Representational State Transfer) is an architectural style for building APIs that uses standard HTTP methods — GET, POST, PUT, DELETE — to perform operations on resources. Each URL represents a resource, and the HTTP method determines the action. REST is the most widely used API style due to its simplicity and predictability.

SaaS is a software distribution model where applications are hosted in the cloud and accessed through a web browser, typically via a subscription. Instead of installing software locally, users access it online. Examples include Slack, Notion, and Stripe. Building a SaaS product involves subscription billing, multi-tenant architecture, user management, and ongoing maintenance.

Scope creep is the gradual expansion of a project's requirements beyond what was originally agreed upon. It typically happens through small, seemingly reasonable additions that individually seem harmless but collectively delay delivery, inflate costs, and dilute focus. A fixed-scope contract and a clear brief are the best defenses.

Server-side rendering is a technique where web pages are generated on the server for each request, rather than in the browser. The server sends fully rendered HTML to the client, which improves initial load time, SEO, and accessibility. Next.js supports SSR alongside static generation and client-side rendering.

A sprint is a fixed time period (usually 1–2 weeks) during which a development team works on a defined set of tasks and delivers working software at the end. Sprints create natural checkpoints for reviewing progress, adjusting priorities, and ensuring the project stays on track.

Static site generation is a technique where web pages are pre-built at compile time rather than generated on each request. The result is plain HTML files that load extremely fast and can be served from a CDN. Best for content that doesn't change frequently — marketing sites, documentation, blogs.

Technical debt is the accumulated cost of shortcuts, outdated decisions, and deferred maintenance in a software codebase. Like financial debt, a small amount is normal — but when it compounds, it slows development, increases bugs, and can eventually make the software more expensive to maintain than to rebuild.

Technical due diligence is an independent assessment of a software product's codebase, architecture, infrastructure, and team capabilities — typically conducted before an acquisition, investment, or major engagement. It reveals hidden risks: technical debt, security vulnerabilities, scalability limitations, and dependency on key personnel.

TypeScript is a programming language built on top of JavaScript that adds static type checking. It catches errors during development rather than at runtime, makes code more self-documenting, and improves IDE support. TypeScript compiles to plain JavaScript and is now the industry standard for professional web development.

Vendor lock-in occurs when a business becomes dependent on a specific technology provider and cannot easily switch to a competitor without significant cost, effort, or data loss. Common in proprietary SaaS platforms, no-code tools, and closed-source frameworks. Open standards and portable architectures reduce this risk.