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.
- 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.
- 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.
- 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 — both essential, but they solve different problems.
- Backend
- The part of the app running on the server, invisible to user. Stores data, processes business logic, talks to other systems. Frontend = what user sees, backend = what happens behind.
- 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.
- 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.
- 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.
- Continuous Deployment
- See CI/CD. Code reaches production automatically after passing tests, without manual intervention.
- Cloud
- Infrastructure no longer in your server room but at AWS, Google Cloud, Hetzner. Pay per use, scale as needed, no hardware purchase. Default for modern apps.
- 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.
- CRUD
- Create, Read, Update, Delete. The four basic operations on any data. «Basic CRUD app» = no complex logic, just stores and displays data.
- 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). Automation, monitoring, infrastructure-as-code, observability.
- Discovery
- Preliminary project phase documenting requirements before writing code. Written spec, clear scope, detailed estimate. Costs €500-€2,000 but saves much more later.
- 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».
- 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.
- Framework
- Toolset solving common problems so you don't reinvent the wheel. Next.js, Laravel, Django are frameworks. Well-chosen accelerates development 30-50%.
- Frontend
- App part user sees and interacts with (browser, mobile app). Tech: React, Vue, Angular, vanilla JS.
- 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.
- HTTPS
- Encrypted web protocol. Should be default for any site in 2026. Without HTTPS = run.
- Integration
- Connection between your app and external system (ANAF, eMAG, Stripe, courier). Each integration is a small pipe between two houses — needs maintenance.
- IP (Intellectual Property)
- Code, design, documentation. Whoever owns IP owns everything. Make sure IP belongs to you from day 1.
- Kubernetes (K8s)
- Container orchestration system at large scale. Useful when you have 10+ servers running your app. For small projects = overkill.
- 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.
- Microservices
- Architecture where app is split into multiple small independent services. Pro: independent scaling. Con: huge complexity. Not for any project.
- Monitoring
- System telling you when something breaks, response speed, error count. Without it, users tell you something's broken — too late.
- MVP
- Minimum Viable Product. Minimum version delivering real value to test a business hypothesis. Not «prototype» (not functional), not «final product». Good MVP = launched in 8-12 weeks with 1-3 critical flows.
- NDA
- Non-Disclosure Agreement. Standard before discovery. Protects your idea and confidential info.
- 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.
- Performance
- How fast app responds. Measured by Core Web Vitals (LCP, INP, CLS). Bad performance loses users — Google measured 53% leave if page loads over 3s.
- Pull request (PR)
- Developer's request for their code to be merged into main version. Goes through code review first.
- 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.
- Rollback
- Returning to previous version when new one breaks. Essential to be able to rollback in seconds, not hours.
- 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.
- SaaS
- Software as a Service. Software you use with monthly subscription, no install. Gmail, Slack, Stripe are SaaS. Dominant business model 2026.
- Scope creep
- Phenomenon where project scope grows gradually without adjusting budget or timeline. Most common cause of project failure.
- SLA
- Service Level Agreement. Specifies guaranteed service level. e.g., «99.9% uptime, 4h critical response». Important post-launch.
- 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.
- Technical debt
- Implicit cost of fast technical decisions made under pressure. Eventually must be paid (refactoring) — otherwise everything slows down.
- Testing
- Automated verification that app works correctly. Types: unit, integration, e2e. Standard: 80%+ coverage.
- 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).
- 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.
- Version control
- See Git. System keeping the history of every code change.
- Webhook
- Automated notification sent by external system when something happens. e.g., Stripe sends webhook when payment succeeds.