IT glossary for non-technical founders
55 terms commonly used in software engineering engagements, explained in accessible language. Sufficient context to formulate informed questions and evaluate technical proposals with confidence.
A
- Agile
- Organizing development in short iterations (2-week sprints) with continuous prioritization and regular feedback. Good agile = bi-weekly demo on real URL; bad agile = scrum master organizing daily standups without delivering.
- API
- Application Programming Interface. The way two applications talk to each other. If your shop sends orders automatically to the courier, that happens through an API. See our API integration and automation services.
- Architecture Decision Record (ADR)
- Short document (1-2 pages) explaining why a technical decision was made (e.g., «why PostgreSQL instead of MongoDB»). Useful so that two years later, when someone asks «why did we do this?», there is a written answer.
- Authentication / Authorization (Auth)
- Authentication = «who are you?» (login). Authorization = «what are you allowed to do?» (permissions). Often mentioned together as «auth». Do not confuse the two: they solve different problems.
B
- Backend
- The part of the app running on the server, invisible to the user. Stores data, processes business logic, talks to other systems. Frontend = what the user sees, backend = what happens behind — both are delivered together in custom web application development.
- Bug
- An error in software. Four practical types: obvious (app crashes), visible (wrong numbers displayed), hidden (data corrupted without anyone noticing), intermittent (only happens Tuesday at 2pm). The last two are the most expensive to fix.
- Build
- The process by which written code becomes a runnable application. «The build broke» = the automated compilation process failed; something does not fit together.
C
- Cache
- Temporary memory storing data for fast access. If the same user requests the same page 100 times, the cache serves the result instantly without recomputing. Benefit: speed. Trap: a stale cache showing outdated information. Applied examples in database and cache optimization.
- CI/CD
- Continuous Integration / Continuous Deployment. Automated system that runs tests when code changes and auto-deploys validated versions. Without CI/CD: manual, risky, slow. With: code in production in minutes — see our plain-English CI/CD guide.
- Cloud
- Infrastructure no longer in your server room but at AWS, Google Cloud, or Hetzner. Pay per use, scale as needed, no hardware purchase. Compare real monthly bills in AWS vs. Hetzner pricing.
- Code review
- Process where a second developer checks code written by the first before merging. Catches bugs, suggests improvements, transfers knowledge. Minimum standard for any serious team and part of our code audit and software consulting.
- Continuous Deployment
- See CI/CD. Code reaches production automatically after passing tests, without manual intervention.
- CRUD
- Create, Read, Update, Delete. The four basic operations on any data. «Basic CRUD app» = no complex logic, just stores and displays data.
D
- Database
- Where data is stored structurally. Types: relational (PostgreSQL, MySQL: tables) or NoSQL (MongoDB, Redis: documents/key-value).
- Deploy
- Action of publishing new code to production for real users. «Friday deploy» = sad industry joke: if it breaks, your weekend is gone.
- DevOps
- Practices uniting development (Dev) with operations (Ops): deployment automation, monitoring, infrastructure-as-code, observability. See our cloud infrastructure and DevOps services.
- Discovery
- Preliminary project phase documenting requirements before writing code. Written spec, clear scope, detailed estimate. Costs €500-€2,000 but saves much more later — see indicative pricing and packages.
- Docker
- Technology that packages an app with all its dependencies in a portable container. Container runs identically on dev laptop, staging, production. Eliminates «works on my machine».
E
- Endpoint
- Specific URL in API responding to a request. e.g.,
/api/users/123returns user 123's data. - Event-driven architecture
- A way of building systems where components communicate through «events» (e.g., «an order was created») instead of calling each other directly. More flexible and resilient, but harder to debug.
F
- Framework
- Toolset solving common problems so you don't reinvent the wheel. Next.js, Laravel, Django are frameworks. Well-chosen accelerates development 30-50% — see Next.js vs. WordPress.
- Frontend
- App part the user sees and interacts with (browser or iOS and Android mobile app). Tech: React, Vue, Angular, vanilla JS.
G
- Git
- Code versioning system. Each commit is a snapshot. Allows multiple devs to work simultaneously without stepping on each other. Industry standard.
- GraphQL
- Alternative to REST API. The client requests exactly the data it needs, in a single request. Useful for mobile apps with limited bandwidth or UIs aggregating data from many sources.
H
- HTTPS
- Encrypted web protocol powered by an SSL/TLS certificate. Should be default for any site in 2026. Without HTTPS = run.
I
- Integration
- Connection between your app and an external system (ANAF, eMAG, Stripe, courier), such as ANAF e-Factura API integration. Each integration is a small pipe between two houses, and it needs maintenance.
- IP (Intellectual Property)
- Code, design, documentation. Whoever owns IP owns everything. Make sure the contract transfers the IP to you. With us: full IP transfer at the end, no hidden licences — see how studios, agencies, and freelancers compare.
K
- Kubernetes (K8s)
- Container orchestration system at large scale. Useful when you have 10+ servers running your app. For small projects = overkill.
L
- Latency
- System response time. Good: under 200ms. Acceptable: 200-500ms. Bad: over 500ms.
- Load balancer
- The «traffic cop» distributing requests across multiple servers. Without one, a single server can drown while others sit idle. Essential for scaling.
M
- Microservices
- Architecture where app is split into multiple small independent services. Pro: independent scaling. Con: huge complexity. Not for every project — see how to choose a startup tech stack.
- Monitoring
- System telling you when something breaks, response speed, error count. Without it, users tell you something's broken, and by then it's too late.
- MVP
- Minimum Viable Product. Minimum version delivering real value to test a business hypothesis. Not «prototype» (not functional — compare MVP vs. prototype), not «final product». Good MVP = launched in 8-12 weeks via startup MVP development with 1-3 critical flows.
N
- NDA
- Non-Disclosure Agreement. Standard before discovery. Protects your idea and confidential info.
O
- Onboarding
- Process where a new user (or developer) learns how the product works. Good = active users in 5 minutes. Bad = immediate abandonment.
- Open source
- Software with public, free-to-use code. Linux, PostgreSQL, React are open source. Pro: huge community, no lock-in. Con: support depends on you.
P
- Performance
- How fast the app responds, measured by Core Web Vitals (LCP, INP, CLS). Bad performance loses users: Google measured 53% leave if a page loads in over 3s. For online shops, see online store speed optimization.
- Pull request (PR)
- Developer's request for their code to be merged into main version. Goes through code review first.
R
- Refactoring
- Rewriting existing code to be cleaner without changing functionality. Periodically necessary, otherwise tech debt accumulates.
- Repository
- Where code is stored, usually on GitHub or GitLab. Contains all modification history, branches, PRs. Should be your property, not the agency's.
- REST API
- Most common API style. Uses URLs and HTTP methods (GET, POST, PUT, DELETE). Standard for most web apps — explained in what is a REST API.
- Rollback
- Returning to previous version when new one breaks. Essential to be able to rollback in seconds, not hours.
S
- SaaS
- Software as a Service. Software you use on a monthly subscription, with no local install. Gmail, Slack, and Stripe are SaaS. See B2B SaaS development and our SaaS MVP cost breakdown.
- Scope creep
- Phenomenon where project scope grows gradually without adjusting budget or timeline. Most common cause of project failure.
- SDK
Software Development Kit - A set of tools that makes integrating with a service easier. Stripe SDK, AWS SDK, Firebase SDK. Simpler than writing code directly against the API.
- SLA
- Service Level Agreement. Specifies guaranteed service level, e.g., «99.9% uptime, 4h critical response». Important post-launch — see software maintenance and SLA costs.
- Sprint
- 1-2 week iteration where team delivers agreed feature set. End: demo + retrospective. Next sprint starts Monday.
- Staging
- Test environment identical to production but without real users. Test there before deploy. Essential to avoid prod surprises.
T
- Technical debt
- Implicit cost of fast technical decisions made under pressure. Eventually must be paid (refactoring), otherwise everything slows down.
- Testing
- Automated verification that the app works correctly: unit, integration, and end-to-end (e2e). Standard: 80%+ coverage — see our automated software testing guide.
- Token
- In an auth context: a long character string identifying an authenticated user. In an AI/LLM context: the unit of text processing (~4 characters = 1 token).
U
- UAT
- User Acceptance Testing. Final phase where real users test app before public launch.
- UX/UI
- UX = how user feels using product (logic flow, friction). UI = how it looks (colors, layout). Both important.
V
- Version control
- See Git. System keeping the history of every code change.
W
- Webhook
- Automated notification sent by an external system when something happens — e.g., Stripe sends a webhook when a payment succeeds. Explained in what is a webhook.