Technical Terms
Core software engineering concepts, architecture patterns, and implementation technologies used in GISE methodology.
Infrastructure & Deployment
Container
Definition: A lightweight, portable package that includes an application and all its dependencies, libraries, and configuration files needed to run in any environment.
Context in GISE: Containers are the preferred deployment method in GISE because they ensure consistency across development, testing, and production environments. The Deploy phase heavily emphasizes container-first deployment strategies.
Example:
# Docker container definition
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["npm", "start"]
Related Terms: Docker, Kubernetes, Hosting, Deploy Phase
Difficulty: 🟡 Intermediate
Hosting
Definition: The infrastructure and services required to make applications accessible over the internet, including servers, networking, and maintenance.
Context in GISE: GISE prioritizes hosting solutions that maintain flexibility and avoid vendor lock-in. Container-based hosting enables easy migration between providers and on-premises infrastructure.
Business Value:
- Cost Control: Avoid vendor lock-in and negotiate better rates
- Flexibility: Move between hosting providers as needs change
- Scalability: Scale resources up or down based on demand
Example Technologies:
- Cloud: AWS ECS, Google Cloud Run, Azure Container Instances
- Platform: Heroku, Railway, Render
- Self-Hosted: Docker Swarm, Kubernetes clusters
Related Terms: Container, Infrastructure as Code, Deploy Phase
Difficulty: 🟡 Intermediate
Cron Job
Definition: A time-based scheduler that automates the execution of scripts or commands at specified intervals in Unix-like operating systems.
Context in GISE: Used for automated maintenance tasks, data processing, cleanup operations, and periodic health checks. Essential for maintaining production systems without manual intervention.
Example:
# Run database cleanup every day at 2 AM
0 2 * * * /usr/local/bin/cleanup-database.sh
# Generate reports every Monday at 9 AM
0 9 * * 1 /usr/local/bin/generate-weekly-report.sh
# Health check every 5 minutes
*/5 * * * * /usr/local/bin/health-check.sh
In Code (Node.js with node-cron):
const cron = require('node-cron');
// Backup database daily at midnight
cron.schedule('0 0 * * *', () => {
console.log('Starting database backup...');
performDatabaseBackup();
});
Related Terms: Automation, Monitoring, Linux, Deploy Phase
Difficulty: 🟡 Intermediate
Data & Storage
Relational Database
Definition: A database that organizes data into tables with rows and columns, using structured relationships between different data entities and supporting SQL queries.
Context in GISE: Preferred database choice because of proven stability, ACID compliance, mature tooling, and widespread expertise. GISE prioritizes long-term maintainability over cutting-edge technology.
Why GISE Chooses Relational Databases:
- Stability: Decades of proven production use
- Consistency: ACID properties ensure data integrity
- Tooling: Mature ecosystem of tools and libraries
- Expertise: Widely understood by development teams
- Compliance: Built-in features for regulatory requirements
Example Schema:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) UNIQUE NOT NULL,
name VARCHAR(255) NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE projects (
id SERIAL PRIMARY KEY,
name VARCHAR(255) NOT NULL,
user_id INTEGER REFERENCES users(id),
status VARCHAR(50) DEFAULT 'active'
);
Common Choices: PostgreSQL (recommended), MySQL, SQL Server
Related Terms: SQL, Database Schema, ORM, Data Modeling
Difficulty: 🟡 Intermediate
Queue
Definition: A data structure and messaging pattern that stores tasks or messages to be processed asynchronously, typically following first-in-first-out (FIFO) ordering.
Context in GISE: Essential for handling background processing, email sending, file processing, and other tasks that shouldn't block the main application flow. Improves user experience and system reliability.
Use Cases:
- Email Processing: Send emails without blocking user requests
- File Processing: Handle uploads, image resizing, document conversion
- Data Processing: Batch operations, report generation
- Integration: External API calls that might be slow or unreliable
Example (Bull MQ with Redis):
import { Queue, Worker } from 'bullmq';
// Create a queue for email processing
const emailQueue = new Queue('email', {
connection: { host: 'localhost', port: 6379 }
});
// Add jobs to the queue
await emailQueue.add('send-welcome', {
email: 'user@example.com',
name: 'John Doe'
});
// Process jobs
const worker = new Worker('email', async (job) => {
const { email, name } = job.data;
await sendWelcomeEmail(email, name);
}, { connection: { host: 'localhost', port: 6379 } });
Related Terms: Redis, Background Jobs, Asynchronous Processing, Worker
Difficulty: 🔴 Advanced
Communication & Networking
HTTP
Definition: Hypertext Transfer Protocol - the foundation protocol for communication on the World Wide Web, defining how messages are formatted and transmitted.
Context in GISE: HTTP-first communication strategy simplifies debugging, monitoring, and integration. GISE avoids complex protocols in favor of well-understood, debuggable HTTP patterns.
Why GISE Prefers HTTP:
- Simplicity: Well-understood by all developers
- Debugging: Easy to inspect with standard tools
- Caching: Built-in caching mechanisms
- Load Balancing: Standard load balancer support
- Monitoring: Extensive tooling for HTTP monitoring
GISE HTTP Patterns:
// RESTful API design
GET /api/users // List users
POST /api/users // Create user
GET /api/users/:id // Get specific user
PUT /api/users/:id // Update user
DELETE /api/users/:id // Delete user
// Server-Sent Events for real-time updates
GET /api/sse/notifications // Stream updates
Alternative: WebSockets only when HTTP/SSE insufficient
Related Terms: REST API, Server-Sent Events, JSON, Status Codes
Difficulty: 🟢 Beginner
API
Definition: Application Programming Interface - a set of protocols, routines, and tools that specify how software components should interact.
Context in GISE: APIs are the contract between frontend and backend systems. GISE emphasizes API-first development with OpenAPI specifications driving implementation.
GISE API Design Principles:
- Contract-First: OpenAPI spec defines the interface
- Consistent: Follow RESTful conventions
- Documented: Auto-generated documentation
- Versioned: Backward compatibility maintained
- Tested: Comprehensive integration testing
Example OpenAPI Specification:
openapi: 3.0.3
info:
title: User Management API
version: 1.0.0
paths:
/users:
get:
summary: List all users
responses:
'200':
description: Successful response
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/User'
components:
schemas:
User:
type: object
properties:
id:
type: integer
email:
type: string
format: email
name:
type: string
Related Terms: REST, OpenAPI, JSON, HTTP, Frontend-Backend Communication
Difficulty: 🟡 Intermediate
Architecture Patterns
Frontend
Definition: The client-side part of an application that users interact with directly, typically running in a web browser or mobile device.
Context in GISE: Frontend is kept separate from backend to enable independent development, deployment, and scaling. Focus is on user experience and consuming backend APIs.
GISE Frontend Principles:
- Separation of Concerns: Clear boundary from backend logic
- API Consumption: Communicates only through well-defined APIs
- User-Centric: Optimized for user experience and performance
- Technology Flexibility: Can be updated independently of backend
Technology Choices:
- Framework: React, Vue.js, Angular, or vanilla JavaScript
- Styling: Tailwind CSS, styled-components, or CSS modules
- State Management: Context API, Zustand, or Redux
- Build Tools: Vite, Webpack, or framework-specific tools
Example Structure:
// Frontend API client
class ApiClient {
async getUsers(): Promise<User[]> {
const response = await fetch('/api/users');
return response.json();
}
async createUser(user: CreateUserRequest): Promise<User> {
const response = await fetch('/api/users', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(user)
});
return response.json();
}
}
Related Terms: Backend, API, Single Page Application, User Interface
Difficulty: 🟡 Intermediate
Backend
Definition: The server-side part of an application that handles business logic, data processing, database operations, and API endpoints.
Context in GISE: Backend focuses on business logic, security, data integrity, and providing APIs for frontend consumption. Separated from frontend for better security and scalability.
GISE Backend Responsibilities:
- Business Logic: Core application functionality and rules
- Data Management: Database operations and data validation
- Security: Authentication, authorization, and data protection
- API Provision: RESTful endpoints for frontend consumption
- Integration: External service and system integration
Architecture Pattern:
// Layered architecture
export class UserController {
constructor(
private userService: UserService,
private authService: AuthService
) {}
@Get('/users')
@UseGuards(AuthGuard)
async getUsers(@Request() req): Promise<User[]> {
return this.userService.findAll();
}
}
export class UserService {
constructor(private userRepository: UserRepository) {}
async findAll(): Promise<User[]> {
return this.userRepository.findAll();
}
}
Technology Choices:
- Runtime: Node.js, Python, Java, .NET
- Framework: NestJS, Express.js, FastAPI, Spring Boot
- Database: PostgreSQL, MySQL, MongoDB
- ORM: Prisma, TypeORM, SQLAlchemy, Hibernate
Related Terms: Frontend, Database, API, Business Logic, Security
Difficulty: 🟡 Intermediate
Security
Authentication
Definition: The process of verifying the identity of a user or system, typically through credentials like username/password, tokens, or biometric data.
Context in GISE: Authentication establishes "who you are" and is the first step in securing applications. GISE prefers simple, secure authentication patterns that are easy to implement and maintain.
GISE Authentication Approach:
- Server-Side: Authentication logic handled by backend
- HTTPOnly Cookies: Secure token storage that frontend can't access
- Same Domain: Avoids CORS complexity in authentication flows
- Session Management: Server-controlled session lifecycle
Example Implementation:
// Login endpoint
@Post('auth/login')
async login(@Body() loginDto: LoginDto, @Res() response: Response) {
const user = await this.authService.validateUser(loginDto.email, loginDto.password);
if (!user) {
throw new UnauthorizedException('Invalid credentials');
}
// Create secure session token
const token = await this.authService.generateToken(user.id);
// Set HTTPOnly cookie
response.cookie('session', token, {
httpOnly: true,
secure: process.env.NODE_ENV === 'production',
sameSite: 'strict',
maxAge: 24 * 60 * 60 * 1000 // 24 hours
});
return { success: true, user };
}
// Protected route guard
@Injectable()
export class AuthGuard implements CanActivate {
async canActivate(context: ExecutionContext): Promise<boolean> {
const request = context.switchToHttp().getRequest();
const token = request.cookies?.session;
if (!token) return false;
const user = await this.authService.validateToken(token);
request.user = user;
return !!user;
}
}
Security Best Practices:
- Never store sensitive data in localStorage or sessionStorage
- Use HTTPS in production for cookie security
- Implement proper session timeout and renewal
- Add rate limiting to prevent brute force attacks
Related Terms: Authorization, Session Management, JWT, Security
Difficulty: 🔴 Advanced
Authorization
Definition: The process of determining what actions a authenticated user is permitted to perform, controlling access to resources and functionality.
Context in GISE: Authorization determines "what you can do" after authentication confirms "who you are". GISE implements role-based access control (RBAC) for most use cases.
GISE Authorization Patterns:
- Role-Based: Users have roles that determine permissions
- Resource-Based: Permissions tied to specific resources
- Hierarchical: Roles can inherit permissions from other roles
- Contextual: Permissions vary based on context (own resources vs others')
Example Implementation:
// Role-based authorization decorator
@Roles('admin', 'manager')
@UseGuards(AuthGuard, RolesGuard)
@Get('admin/users')
async getAdminUsers(): Promise<User[]> {
return this.userService.findAll();
}
// Resource-based authorization
@UseGuards(AuthGuard, ResourceOwnerGuard)
@Put('users/:id')
async updateUser(
@Param('id') id: string,
@Body() updateDto: UpdateUserDto,
@User() currentUser: User
): Promise<User> {
// ResourceOwnerGuard ensures user can only update their own profile
// unless they have 'admin' role
return this.userService.update(id, updateDto);
}
// Authorization guard implementation
@Injectable()
export class RolesGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(context: ExecutionContext): boolean {
const requiredRoles = this.reflector.getAllAndOverride<string[]>('roles', [
context.getHandler(),
context.getClass(),
]);
if (!requiredRoles) return true;
const { user } = context.switchToHttp().getRequest();
return requiredRoles.some(role => user.roles?.includes(role));
}
}
Common Authorization Patterns:
- Public: No authentication required
- Authenticated: Must be logged in
- Role-Based: Must have specific role
- Owner: Can only access own resources
- Admin: Full system access
Related Terms: Authentication, RBAC, Permissions, Security Guards
Difficulty: 🔴 Advanced
Development Tools & Practices
Git
Definition: A distributed version control system that tracks changes in source code during software development, enabling collaboration and maintaining project history.
Context in GISE: Git is central to the GISE methodology. The "GIT-First" approach means everything is version controlled - code, documentation, diagrams, and configuration.
GISE Git Workflow:
- Feature Branches: Each phase of 4D methodology uses dedicated branches
- Pull Requests: Quality gates and collaboration mechanism
- Documentation: Markdown and Mermaid diagrams in version control
- Linear History: Clean, readable project progression
Example GISE Git Workflow:
# Start new feature following 4D methodology
git checkout main
git pull origin main
git checkout -b feature/discover-user-management
# Discover phase work
git add requirements.md user-stories.md
git commit -m "feat: add user management requirements and stories"
# Continue with process flows
git add process-flows/
git commit -m "feat: add user management process diagrams"
# Create pull request for discover phase
git push origin feature/discover-user-management
# Open PR: "Discover Phase: User Management Requirements"
# After review and merge, start design phase
git checkout main
git pull origin main
git checkout -b feature/design-user-management
# Design phase work
git add architecture.md database-schema.sql api-spec.yaml
git commit -m "feat: add user management system design"
Branch Naming Convention:
feature/discover-[feature-name]- Requirements and analysisfeature/design-[feature-name]- Architecture and designfeature/develop-[feature-name]- Implementation and testingfeature/deploy-[feature-name]- Deployment and operations
Related Terms: Pull Request, Feature Branch, Version Control, Collaboration
Difficulty: 🟡 Intermediate
Pull Request
Definition: A feature in version control systems that lets developers propose changes to a codebase and request review before merging into the main branch.
Context in GISE: Pull requests are the primary quality gate and collaboration mechanism. Each phase of the 4D methodology ends with a pull request review before proceeding to the next phase.
GISE Pull Request Process:
- Phase Completion: Complete all deliverables for a phase
- Self-Review: Developer reviews their own work first
- Create PR: Submit for team review with clear description
- Peer Review: Team members review for quality and completeness
- Iterations: Address feedback and make improvements
- Approval: Get required approvals before merging
- Merge: Integrate changes and prepare for next phase
Pull Request Template:
## GISE Phase: [Discover/Design/Develop/Deploy]
### Summary
Brief description of what was completed in this phase.
### Deliverables
- [ ] [Key deliverable 1]
- [ ] [Key deliverable 2]
- [ ] [Key deliverable 3]
### Phase-Specific Checklist
#### Discover Phase
- [ ] Requirements documented and validated
- [ ] User stories created and prioritized
- [ ] Process flows mapped with Mermaid diagrams
- [ ] Technology research completed
### Changes Made
- Added requirements.md with complete user story breakdown
- Created process flow diagrams for current and future state
- Researched technology stack with decision matrix
### Review Focus
Please pay special attention to:
- Completeness of requirements coverage
- Clarity of user stories and acceptance criteria
- Accuracy of process flow diagrams
### Next Steps
After merge, the next phase will focus on:
- System architecture design
- Database schema planning
- API specification creation
Quality Gates by Phase:
- Discover: Requirements completeness, stakeholder validation
- Design: Architecture review, technical feasibility
- Develop: Code quality, test coverage, functionality
- Deploy: Production readiness, documentation completeness
Related Terms: Git, Code Review, Quality Assurance, Collaboration
Difficulty: 🟡 Intermediate
Markdown
Definition: A lightweight markup language that uses plain text formatting syntax to create formatted documents, widely used for documentation and README files.
Context in GISE: Markdown is the primary documentation format because it's version-controllable, readable as plain text, and renders beautifully in web interfaces.
GISE Markdown Usage:
- Requirements Documentation: All project requirements in Markdown
- User Stories: Structured user story templates
- Architecture Decisions: Decision records and rationale
- API Documentation: Supplement to OpenAPI specifications
- Process Documentation: Step-by-step guides and runbooks
GISE Markdown Templates:
# Requirements Document
## Project Overview
- **Project Name**: [Name]
- **Business Objective**: [Goal]
- **Success Criteria**: [Metrics]
## User Stories
### Epic: [High-level feature]
#### Story: [Specific functionality]
**As a** [user type]
**I want** [capability]
**So that** [business value]
**Acceptance Criteria:**
- [ ] [Testable criterion 1]
- [ ] [Testable criterion 2]
- [ ] [Testable criterion 3]
**Definition of Done:**
- [ ] Implementation complete
- [ ] Tests passing
- [ ] Documentation updated
Why Markdown in GISE:
- Version Control: Works perfectly with Git
- Simplicity: Easy to write and read
- Portability: Renders in any text editor or web interface
- Collaboration: Easy to review and suggest changes
- Integration: Pairs well with Mermaid diagrams
Related Terms: Documentation, Version Control, Mermaid, Technical Writing
Difficulty: 🟢 Beginner
Mermaid
Definition: A text-based diagramming language that generates diagrams and flowcharts from text definitions, enabling version-controllable visual documentation.
Context in GISE: Mermaid is essential for visual documentation because diagrams are defined as text, making them version-controllable and easy to maintain alongside code.
GISE Mermaid Usage:
- Process Flows: Document business processes and workflows
- System Architecture: Visualize system components and relationships
- User Journeys: Map user interactions and decision points
- Git Workflows: Show branching and merging strategies
- Database Schemas: Entity relationship diagrams
Common GISE Mermaid Patterns:
Benefits in GISE:
- Version Controlled: Diagrams evolve with code
- Maintainable: Easy to update as systems change
- Collaborative: Can be reviewed like code
- Accessible: Renders in GitHub, GitLab, and documentation sites
Related Terms: Documentation, Diagrams, Architecture, Process Flow
Difficulty: 🟡 Intermediate
Development Methodologies
Triage
Definition: The process of prioritizing and categorizing issues, tasks, or requirements based on urgency, impact, and available resources.
Context in GISE: Triage is used throughout all phases to make decisions about what to work on first, which issues are critical, and how to allocate limited time and resources effectively.
GISE Triage Applications:
- Requirements Triage: Which requirements are must-have vs nice-to-have
- Issue Triage: Bug severity and resolution priority
- Feature Triage: Which features provide the most business value
- Technical Debt: What needs immediate attention vs can wait
Triage Matrix Example:
# Feature Triage Matrix
| Feature | Business Value | Implementation Effort | Priority |
|---------|---------------|----------------------|----------|
| User Authentication | High | Medium | P0 (Critical) |
| Password Reset | Medium | Low | P1 (Important) |
| Social Login | Low | High | P3 (Optional) |
| Two-Factor Auth | Medium | Medium | P2 (Nice to Have) |
## Priority Levels
- **P0 (Critical)**: Must have for launch
- **P1 (Important)**: Should have for good UX
- **P2 (Nice to Have)**: Could improve experience
- **P3 (Optional)**: Future enhancement
Triage Decision Factors:
- Business Impact: Revenue, user satisfaction, competitive advantage
- Technical Risk: Complexity, dependencies, unknowns
- Resource Constraints: Time, team capacity, budget
- Dependencies: What blocks other work if not completed
Related Terms: Priority Management, Resource Allocation, Project Planning
Difficulty: 🟡 Intermediate
Analysis
Definition: The systematic examination of requirements, problems, or systems to understand their components, relationships, and implications for design and implementation.
Context in GISE: Analysis is primarily focused in the Discover phase but continues throughout all phases. It involves breaking down complex problems into manageable components and understanding their relationships.
Types of Analysis in GISE:
Requirements Analysis:
# Requirements Analysis Framework
## Functional Requirements
- **Core Features**: What the system must do
- **Business Rules**: How the system should behave
- **Integration Points**: External systems and APIs
- **Data Requirements**: What information is managed
## Non-Functional Requirements
- **Performance**: Speed, throughput, scalability
- **Security**: Authentication, authorization, data protection
- **Usability**: User experience and accessibility
- **Reliability**: Uptime, error handling, recovery
## Constraints
- **Technical**: Platform limitations, legacy systems
- **Business**: Budget, timeline, regulatory compliance
- **Organizational**: Team skills, change management
Gap Analysis:
# Current vs Future State Analysis
| Aspect | Current State | Future State | Gap | Priority |
|--------|--------------|--------------|-----|----------|
| User Management | Manual CSV import | Automated API sync | Integration layer needed | High |
| Reporting | Monthly Excel reports | Real-time dashboard | Analytics engine needed | Medium |
| Authentication | Basic login | SSO with MFA | Identity provider integration | High |
Risk Analysis:
- Technical Risks: Complex integrations, new technology
- Business Risks: Changing requirements, market conditions
- Resource Risks: Team availability, skill gaps
- Timeline Risks: Dependencies, scope creep
Related Terms: Requirements Gathering, Risk Assessment, Gap Analysis
Difficulty: 🟡 Intermediate
Design
Definition: The process of planning and creating the architecture, interfaces, and detailed specifications for a software system before implementation begins.
Context in GISE: Design is the second phase of the 4D methodology, focusing on creating comprehensive technical specifications that guide development work.
GISE Design Deliverables:
System Architecture:
Database Design:
-- User management schema
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL,
name VARCHAR(255) NOT NULL,
role VARCHAR(50) DEFAULT 'user',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE user_sessions (
id SERIAL PRIMARY KEY,
user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
token_hash VARCHAR(255) NOT NULL,
expires_at TIMESTAMP NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX idx_user_sessions_token ON user_sessions(token_hash);
CREATE INDEX idx_user_sessions_expires ON user_sessions(expires_at);
API Design (OpenAPI):
paths:
/api/users:
get:
summary: List users
parameters:
- name: page
in: query
schema:
type: integer
minimum: 1
default: 1
- name: limit
in: query
schema:
type: integer
minimum: 1
maximum: 100
default: 20
responses:
'200':
description: Users retrieved successfully
content:
application/json:
schema:
type: object
properties:
users:
type: array
items:
$ref: '#/components/schemas/User'
pagination:
$ref: '#/components/schemas/Pagination'
Design Validation Criteria:
- Scalability: Can handle expected load and growth
- Security: Implements proper authentication and authorization
- Maintainability: Easy to understand, modify, and extend
- Performance: Meets response time and throughput requirements
- Compliance: Follows regulatory and organizational standards
Related Terms: Architecture, Database Schema, API Specification, System Design
Difficulty: 🔴 Advanced
Regression Testing
Definition: Testing that verifies previously working functionality still works correctly after code changes, ensuring that new features or bug fixes don't break existing features.
Context in GISE: Regression testing is essential during the Develop phase to maintain system reliability as code evolves. GISE emphasizes automated regression testing for efficiency and consistency.
GISE Regression Testing Strategy:
Test Pyramid Structure:
Automated Test Example:
// Integration test for user registration
describe('User Registration API', () => {
beforeEach(async () => {
await cleanupDatabase();
await seedTestData();
});
it('should create new user with valid data', async () => {
const userData = {
email: 'test@example.com',
name: 'Test User',
password: 'SecurePassword123!'
};
const response = await request(app)
.post('/api/users')
.send(userData)
.expect(201);
expect(response.body).toMatchObject({
id: expect.any(Number),
email: userData.email,
name: userData.name
});
expect(response.body).not.toHaveProperty('password');
// Verify user can log in
const loginResponse = await request(app)
.post('/api/auth/login')
.send({
email: userData.email,
password: userData.password
})
.expect(200);
expect(loginResponse.body.success).toBe(true);
});
it('should reject duplicate email addresses', async () => {
const userData = {
email: 'duplicate@example.com',
name: 'First User',
password: 'SecurePassword123!'
};
// Create first user
await request(app)
.post('/api/users')
.send(userData)
.expect(201);
// Attempt to create duplicate
await request(app)
.post('/api/users')
.send({ ...userData, name: 'Second User' })
.expect(409);
});
});
GISE Testing Principles:
- No Flow Testing: Never unit test service → database → response flows
- Integration Focus: Test complete user journeys and API contracts
- Truth Table Testing: Unit test only for pure functions with clear inputs/outputs
- Automation: All regression tests run automatically on every commit
Test Categories:
- API Tests: Verify all endpoints work correctly
- Database Tests: Ensure data integrity and constraints
- Authentication Tests: Verify security functions properly
- Business Logic Tests: Test core functionality end-to-end
Related Terms: Automated Testing, Quality Assurance, Continuous Integration
Difficulty: 🔴 Advanced
Quick Reference
Essential Terms for New Users
Start with these fundamental concepts:
- Container - Application packaging and deployment
- API - Interface between frontend and backend
- Git - Version control for everything
- Pull Request - Quality gate and collaboration
- Markdown - Documentation format
- HTTP - Communication protocol
Terms by GISE Phase
- Discover: Analysis, Triage, Requirements
- Design: Architecture, Database Schema, API Specification
- Develop: Frontend, Backend, Authentication, Authorization
- Deploy: Container, Hosting, Cron Job, Monitoring
Related Resources
- Methodology Terms - GISE-specific concepts
- GenAI Terms - AI and machine learning terminology
- Recipe Database - Practical implementations using these terms
Technical terminology evolves with technology. These definitions reflect current best practices and GISE methodology applications.