IT glossary for non-technical founders
50 terms you'll hear in any meeting with a software agency, explained in human language. No jargon that makes your head spin. No pretense that you must become a developer. Just enough so you can ask intelligent questions and detect when someone is trying to impress you with big words instead of 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.
- 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.
- 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.
- 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.
- 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. - 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.
- 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.
- 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.
- 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.
- 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.
- Webhook
- Automated notification sent by external system when something happens. e.g., Stripe sends webhook when payment succeeds.