Skip to content

Serhii Smetanskyi

Archive

Home
About
Services
CV
Blog
Docs
Projects
Tags
Archive
Contact

Serhii Smetanskyi

Home
About
Services
CV
Blog
Blog
- Archive
  Archive
  - 2026
- Categories
  Categories
  - AI Testing
  - Automation
  - QA
Docs
Docs
- API Architectures
  API Architectures
- Client–Server Architecture
  Client–Server Architecture
  - Core Model
    
    Core Model
    
    Client-Server Architecture: Core Model
    
    Client-Server: API Architectures Overview
  - Edge Layer
    
    Edge Layer
    
    Edge Layer: CDN and Load Balancers
    
    Edge Layer: Reverse Proxy, Forward Proxy, API Gateway, WAF
  - Traffic Service Mesh
    
    Traffic Service Mesh
    
    Traffic Management
    
    Service Layer and Service Mesh
  - Connections Backpressure
    
    Connections Backpressure
    
    Connection Management
    
    Backpressure and Flow Control
  - Client Scalability Performance
    
    Client Scalability Performance
    
    Client Architecture
    
    Scalability
    
    Performance
  - Reliability Security Observability
    
    Reliability Security Observability
    
    Reliability
    
    Security
    
    Observability
  - Testing Risks Patterns
    
    Testing Risks Patterns
    
    Testing
    
    Risks, Limitations, and Anti-Patterns
    
    Real-World Patterns and Decision Factors
- Software Design Patterns and Principles
  Software Design Patterns and Principles
  - Design Principles
    
    Design Principles
    
    OOP — Fundamentals
    
    Design Principles: SOLID
    
    Design Principles: Beyond SOLID
    
    Clean Code
    
    Code Quality Tools
  - Creational Patterns
    
    Creational Patterns
    
    Creational Patterns
  - Structural Patterns
    
    Structural Patterns
    
    Structural Patterns: Adapter, Decorator, Facade
    
    Structural Patterns: Proxy, Composite, Bridge, Flyweight
  - Behavioral Patterns
    
    Behavioral Patterns
    
    Behavioral Patterns: Strategy, Observer, Command
    
    Behavioral Patterns: Chain of Responsibility, State, Mediator
    
    Behavioral Patterns: Iterator, Template Method, Visitor
  - Composition Architectural
    
    Composition Architectural
    
    Composition and Advanced Structuring Patterns
    
    Architectural Patterns: Layered, Clean, Hexagonal
    
    Architectural Patterns: Microservices, Event-Driven, Isomorphic
    
    Queues vs Streams: Message Delivery, Ordering & Reliability
  - Frontend Cross Layer
    
    Frontend Cross Layer
    
    View Layer Patterns
    
    Cross-Layer Design Patterns
  - Decisions Testing Production
    
    Decisions Testing Production
    
    Pattern Comparison and Testing Strategies
    
    Anti-Patterns, Real-World Usage, Heuristics, and Decision Factors
    
    Microservice Production Readiness Checklist
- Agentic AI Architecture
  Agentic AI Architecture
- AI Skills for Coding Agents
  AI Skills for Coding Agents
- AI Harness
  AI Harness
- Spec-Driven Development
  Spec-Driven Development
- Code Security
  Code Security
- OWASP API Security
  OWASP API Security
- OWASP LLM Security
  OWASP LLM Security
  - OWASP LLM Security Guide (2026)
  - OWASP LLM Security Testing Checklist (2026)
- QA & Testing Methodology
  QA & Testing Methodology
- Test Design Techniques
  Test Design Techniques
  - Input Based
    
    Input Based
    
    Equivalence Partitioning
    
    Boundary Value Analysis
    
    Pairwise Testing
  - Logic State Based
    
    Logic State Based
    
    Decision Table Testing
    
    State Transition Testing
  - Experience Based
    
    Experience Based
    
    CRUD Testing
    
    Metamorphic Testing
    
    Fuzz & Random Testing
- Test Design Patterns in Test Automation
  Test Design Patterns in Test Automation
  - Fundamentals
    
    Fundamentals
    
    Test Types and Levels
    
    Test Pyramid, Trophy and Core Principles
    
    Test Architecture
  - Core Patterns
    
    Core Patterns
    
    Page Object Model (POM)
    
    Screenplay Pattern
    
    Test Data Builder
    
    Fixture Pattern and Factory Pattern
  - Advanced Patterns
    
    Advanced Patterns
    
    Wrapper / Abstraction Layer and Fluent Interface Pattern
    
    Assertion Pattern, Test Template Pattern, Data-Driven Pattern
  - API Test Patterns
    
    API Test Patterns
    
    API Test Patterns: REST and GraphQL
    
    API Test Patterns: gRPC and WebSocket
  - Data Mocking Env
    
    Data Mocking Env
    
    Test Data Management
    
    Mocking and Stubbing
    
    Test Environment Design
  - Execution Reliability
    
    Execution Reliability
    
    Test Execution Strategies
    
    Test Reliability and Flakiness
    
    Performance Testing and Observability in Tests
  - Decisions Production
    
    Decisions Production
    
    CI/CD Integration and Security Testing
    
    Test Anti-Patterns and Risks
    
    Real-World Test Architectures, Decision Factors, and Heuristics
- Testing Pyramid
  Testing Pyramid
  - Unit Tests
    
    Unit Tests
    
    Unit Tests — Concept & Examples
    
    Unit Tests — Common Mistakes
  - Integration Tests
    
    Integration Tests
    
    Integration Tests — Concept & Examples
    
    Integration Tests — Common Mistakes
  - E2E Tests
    
    E2E Tests
    
    E2E Tests — Concept & Examples
    
    E2E Tests — Common Mistakes
  - Pyramid Strategy
    
    Pyramid Strategy
    
    Pyramid Shape, Anti-Patterns & Alternatives
- Test Automation Framework
  Test Automation Framework
  - Architecture
    
    Architecture
    
    Framework Goals & Core Principles
    
    Framework Architecture — Layers & Responsibilities
    
    Framework Directory Structure
  - Design Patterns
    
    Design Patterns
    
    UI Test Design Patterns
    
    API & Data Test Design Patterns
    
    Advanced Framework Patterns
  - Test Data
    
    Test Data
    
    Test Data Strategies & Isolation
    
    Builders, Factories & DB Seeding
  - API Testing
    
    API Testing
    
    API Testing — REST & GraphQL
    
    API Testing — gRPC & WebSocket
  - UI Testing
    
    UI Testing
    
    UI Testing — Tools & Patterns
    
    UI Testing — Wait Strategies, Retry & Selector Abstraction
  - Execution Reliability
    
    Execution Reliability
    
    Test Execution — Parallel & Test Organisation
    
    Reliability & Flakiness
    
    Mocking & Test Isolation
  - Config CI/CD Decisions
    
    Config CI/CD Decisions
    
    Configuration Management
    
    Logging, Reporting & Observability
    
    CI/CD Integration
    
    Performance Testing Support & Security Testing
    
    Framework Extensibility & Anti-Patterns
    
    Risks, Real-World Patterns & Decision Heuristics
- Robot Framework
  Robot Framework
  - Fundamentals
    
    Fundamentals
    
    Core Syntax & Test Structure
    
    Keywords & Variables
    
    Libraries & Extensibility
  - Architecture
    
    Architecture
    
    Layered Architecture
    
    Keyword Design Principles
    
    Test Data Management
  - API Testing
    
    API Testing
    
    API Testing Architecture & Patterns
    
    Request Design & Validation Strategy
    
    API Testing — Step by Step
    
    Practical — Full API Framework
  - UI Testing
    
    UI Testing
    
    Page Object Pattern & Locators
    
    Wait Strategies & Flakiness Control
    
    UI Testing — Step by Step
    
    Practical — Full UI Framework
  - Execution & Reliability
    
    Execution & Reliability
    
    Parallel Execution with Pabot
    
    Error Handling & Retry Patterns
    
    Setup, Teardown & Test Organization
  - Infrastructure
    
    Infrastructure
    
    Configuration & Secrets Management
    
    Logging, Debugging & Reporting
    
    CI/CD Integration
  - Decisions & Production
    
    Decisions & Production
    
    Scalability & Maintainability
    
    Anti-Patterns, Risks & Limitations
    
    Maturity Model & Engineering Heuristics
- DeepEval — LLM Testing Guide
  DeepEval — LLM Testing Guide
- Performance Testing
  Performance Testing
  - Fundamentals Metrics
    
    Fundamentals Metrics
    
    Performance Testing — Goals & Types
    
    Core Metrics
    
    Metric Relationships
  - Locust
    
    Locust
    
    Locust — Architecture & Basics
    
    Load Modeling
    
    Test Design in Locust
    
    Metrics Analysis in Locust
    
    Advanced Locust Usage
  - Bottlenecks Monitoring
    
    Bottlenecks Monitoring
    
    Performance Bottlenecks
    
    Monitoring & Observability
  - Execution Results
    
    Execution Results
    
    SLA / SLO
    
    Test Execution Strategy
    
    Interpreting Results
    
    Pitfalls, Real-World Scenarios & Heuristics
- Python Guide
  Python Guide
  - Setup & Fundamentals
    
    Setup & Fundamentals
    
    Environment Setup
    
    Data Types & Variables
    
    Control Flow & Loops
    
    Data Structures
    
    Functions & Modules
  - OOP & Error Handling
    
    OOP & Error Handling
    
    Classes & Objects
    
    Inheritance & Composition
    
    Exceptions & Logging
    
    Files & Data Formats
  - Testing with pytest
    
    Testing with pytest
    
    Testing Fundamentals
    
    pytest Basics
    
    Fixtures & Parametrize
    
    Test Architecture
    
    Assertions & Mocking
  - Automation
    
    Automation
    
    API Testing
    
    UI Automation
    
    Test Design Patterns
  - Code Quality & CI/CD
    
    Code Quality & CI/CD
    
    Code Quality Tools
    
    Dependency Management
    
    CI/CD Integration
  - Advanced Topics
    
    Advanced Topics
    
    Decorators & Generators
    
    Context Managers & Async
    
    Performance & Optimization
  - Best Practices
    
    Best Practices
    
    Security
    
    Common Pitfalls
    
    Interview Readiness
    
    Recommended Stack
    
    Further Learning
- Jenkins Guide
  Jenkins Guide
  - Fundamentals
    
    Fundamentals
    
    What Is a Jenkinsfile
    
    Declarative vs Scripted
  - Declarative Syntax
    
    Declarative Syntax
    
    Pipeline, Agent & Options
    
    Stages & Steps
    
    Post, Triggers & Tools
  - Advanced Features
    
    Advanced Features
    
    Parameters & Environment
    
    When Conditions & Parallel
    
    Shared Libraries
  - Patterns & Best Practices
    
    Patterns & Best Practices
    
    Security & Performance
    
    Real-World Templates
- CI/CD
  CI/CD
  - Fundamentals
    
    Fundamentals
    
    CI/CD — Concepts & Goals
    
    Pipeline Architecture
  - Build Artifacts
    
    Build Artifacts
    
    Build Stage
    
    Artifact Management
  - Testing
    
    Testing
    
    Testing in CI/CD — Layers & Strategy
    
    Quality Gates
  - Deployment
    
    Deployment
    
    Deployment Strategies
    
    Infrastructure & Infrastructure as Code
    
    Environment Management
  - Security Observability
    
    Security Observability
    
    Security in CI/CD
    
    Pipeline Observability
    
    Pipeline Performance & Optimisation
  - Release Production
    
    Release Production
    
    Release Management
    
    Rollback Strategies
    
    Testing in Production
  - Patterns Decisions
    
    Patterns Decisions
    
    Advanced CI/CD Patterns
    
    Failure Handling in CI/CD
    
    Anti-Patterns & Risks
    
    Real-World Architectures, Heuristics & Decision Factors
- Databases
  Databases
  - PostgreSQL
    
    PostgreSQL
    
    PostgreSQL — Commands & psql
    
    PostgreSQL — Schema & Data Types
    
    PostgreSQL — Queries & Performance
    
    PostgreSQL — Admin & Operations
    
    PostgreSQL — Basic Query Commands
- Tools
  Tools
- Python Libraries
  Python Libraries
Projects
Projects
- Archive
  Archive
  - 2026
  - 2025
- Categories
  Categories
Tags
Archive
Contact

Archive¶

Everything from the blog, docs and projects, newest first.

Serhii Smetanskyi Software Test & Automation Engineer

Home About Services CV Blog Docs Projects Tags Archive Contact

© 2026 Serhii Smetanskyi