Software terms, defined plainly.

An API is the agreed way one piece of software talks to another. It lets your app ask another system for data or actions without knowing how that system works inside. When people say two tools integrate, an API is usually what's doing the talking.

The backend is the part of an app you never see: the servers, databases and logic that store your data and do the heavy work. When you save a record or log in, the backend is what handles it. It pairs with the frontend, which is the part on your screen.

CI/CD is the pipeline that takes new code, checks it automatically, and ships it to your users. CI catches problems early by testing every change; CD pushes the approved changes out without a risky manual release. The point is to release small updates often, safely.

Cloud hosting means your software runs on servers you rent from a provider instead of machines you own and maintain. You pay for what you use and can add capacity when traffic grows. It's why a small team can run software that handles a lot of users.

A CMS, or content management system, lets non-technical people edit a site's words and images without touching code. Marketing can update a page, publish a post or swap a photo on their own. It keeps day-to-day content changes out of the development queue.

Code review is when another engineer reads a change before it ships. They look for bugs, unclear logic and anything that could cause trouble later. It's one of the cheapest ways to keep quality up and spread knowledge across a team.

Cross-platform means one codebase that runs on more than one system, such as a single app that works on both iPhone and Android. It usually costs less than building each version separately. The trade-off is a bit less access to the deepest device-specific features.

A database is the organised store where an app keeps its data: users, orders, messages, everything. It's built so the software can find and update the right record quickly, even with millions of them. Most of what an app remembers lives in one.

DevOps is the practice of getting the people who build software and the people who run it working as one. The goal is faster, calmer releases and systems that stay up. In practice it covers automation, monitoring and the pipeline that ships your code.

The frontend is everything the user sees and touches: the screens, buttons, forms and layout. It runs in the browser or on the device. It talks to the backend to fetch and save data, but the look and feel are its job.

An integration connects your software to another tool so they share data or trigger each other. Linking a checkout to a payment provider or syncing leads into a CRM are common examples. Good integrations save people from copying data by hand between systems.

Latency is the delay between asking software to do something and seeing it respond. Low latency feels instant; high latency feels laggy. It matters most for things like search, chat and anything a user is waiting on in real time.

A legacy system is older software a business still depends on, even though it's hard to change or running on dated technology. It often holds important data and rules nobody wants to break. Replacing or modernising one carefully is a project in itself.

An MVP, or minimum viable product, is the smallest version of an idea that's still worth using. You build it to learn whether people want the thing before spending on every feature. The aim is real feedback early, not a stripped-down product forever.

Open-source software has its code published for anyone to read, use and improve, usually for free. A lot of the tools modern apps are built on are open source. It can lower cost and avoid lock-in, though someone still has to keep it updated.

A PWA, or progressive web app, is a website that behaves like an installed app. It can be added to a home screen, work offline in part, and send notifications, all without an app store. It's a practical middle ground between a site and a native app.

QA, or quality assurance, is the work of checking software does what it should before users get it. It covers testing features, hunting for bugs and confirming fixes actually hold. Done well, it's about preventing problems, not just finding them late.

Refactoring is tidying up the inside of code without changing what it does for users. Engineers do it to make the code easier to read, safer to change and faster to build on. It's maintenance that pays off in every feature that comes after.

Responsive design means a site or app reshapes itself to fit any screen, from a phone to a wide monitor. Text reflows, menus adapt and nothing important gets cut off. It's now the baseline, since most people will visit on a phone at some point.

SaaS, or software as a service, is software you use over the internet and pay for by subscription instead of buying once and installing. Updates happen on the provider's side, so you're always on the current version. Most business tools you log into are SaaS.

Scalability is how well software copes as demand grows, whether that's more users, more data or more traffic at once. A scalable system handles a busy day without slowing to a crawl or falling over. Planning for it early is cheaper than retrofitting it later.

Scope creep is when a project quietly grows beyond what was agreed, one small addition at a time. Each request seems minor, but together they stretch the budget and the deadline. The fix is a clear scope and an honest conversation whenever something new comes up.

An SDK, or software development kit, is a bundle of ready-made tools a provider gives developers to build on their service. It saves a team from writing common code from scratch. If your app adds maps, payments or analytics, it probably uses an SDK.

Server-side rendering builds a page on the server and sends it ready to view, so it shows up fast and search engines can read it easily. The alternative builds the page in the browser, which can be slower on the first load. SSR is common for content-heavy and public sites.

An SLA, or service-level agreement, is a written promise about how a service will perform, such as how much uptime to expect or how fast issues get a response. It sets clear expectations and says what happens if they're missed. You'll see SLAs around hosting and support.

A sprint is a short, fixed stretch of work, often two weeks, with a small set of goals agreed at the start. At the end the team has something to show and a chance to adjust. Working in sprints keeps progress visible and plans easy to change.

SSO, or single sign-on, lets people log in once and reach several connected apps without signing in again each time. It's more convenient for users and easier for IT to control access. Logging into a tool with your Google or work account is SSO in action.

Staff augmentation is adding outside engineers or specialists to your own team to fill a gap or add capacity. They work inside your process and tools, and you direct the work day to day. It's a flexible way to scale up without a long hiring cycle.

A static site serves pages that are already built, rather than assembling them fresh for each visit. That makes it fast, cheap to host and hard to break. It suits content that doesn't change per user, like a marketing site or documentation.

Technical debt is the future cost of a shortcut taken to ship something sooner. Like a loan, it's fine in moderation, but it charges interest: code gets harder to change until you pay it down. Some is normal; the trick is keeping it visible and under control.

Uptime is the share of time your software is up and working, usually quoted as a percentage. The closer to 100 percent, the fewer outages your users hit. Even small drops add up, so it's a number worth agreeing on for anything people depend on.

UX, or user experience, is how it feels to use a product: how clear, quick and frustration-free it is to get things done. It covers far more than looks, taking in flow, wording and the small decisions that add up. Good UX is mostly invisible; bad UX you notice at once.

Version control records every change to a codebase, who made it and why, so a team can work in parallel and roll back if needed. It's the safety net that lets several engineers touch the same project without overwriting each other. Git is the tool nearly everyone uses for it.

A webhook is an automatic message one system sends another the moment something happens, like a payment going through. Instead of your app constantly asking whether something changed, the other system tells it right away. It keeps connected tools in sync without delay.