These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Knows ChatGPT and Claude capabilities for technical writing tasks: draft generation, rewriting, translation, code sample creation. Understands LLM limitations: potential inaccuracies, knowledge staleness, need for verification.
Effectively uses ChatGPT and Claude in daily work: creating boilerplate documentation, generating code samples, reformulating complex technical concepts. Creates system prompts for documentation tasks.
Integrates LLMs into documentation workflow: auto-generation from code comments, review drafts, consistency checking. Defines best practices for team AI usage: when to use, what to verify, which tasks not to delegate to AI.
Shapes the policy for AI assistant usage in the documentation team. Evaluates ROI of various LLM tools. Implements custom solutions based on ChatGPT/Claude APIs for specific documentation tasks.
Knows GitHub Copilot capabilities for documentation creation: Markdown autocompletion, code sample generation, code comment creation. Understands limitations and the need to verify Copilot suggestions.
Effectively uses Copilot in daily work: generating Markdown templates, auto-completing technical descriptions, creating code examples. Configures Copilot context through template files for documentation style consistency.
Integrates Copilot into documentation workflow: uses Copilot Chat for code analysis and description generation, creates custom instructions. Defines best practices for Copilot usage in the documentation team.
Defines strategy for AI-assisted writing tools in the documentation team. Evaluates productivity gains, manages licenses. Establishes guidelines for responsible AI tool usage.
AI in Development Workflows
▼
Knows about AI tool capabilities for documentation generation (ChatGPT, Claude, GitHub Copilot). Understands AI generation limitations: hallucinations, outdated data, loss of context. Uses AI for creating drafts of simple descriptions.
Effectively applies AI to accelerate documentation: boilerplate generation, paraphrasing technical descriptions, creating code examples. Develops prompts adapted to the project documentation style and tone of voice. Always verifies AI output.
Builds workflow for integrating AI into the documentation process: auto-generation from code, review pipeline, human-in-the-loop validation. Defines AI applicability boundaries and cases where manual writing is preferred. Trains the team on safe AI usage.
Defines AI strategy for the documentation team: which tasks to automate, which to keep manual. Implements custom fine-tuned models or RAG approaches for documentation generation with project codebase knowledge. Establishes AI documentation quality metrics.
Algorithms & Data Structures
▼
Understands basic algorithms and Big-O notation for correctly describing API performance in documentation. Knows main search and sorting algorithms, can describe their behavior in technical guides. Documents limitations and performance characteristics of simple API methods.
Documents algorithmic complexity of API methods and includes performance guidelines in reference guides. Creates benchmark documentation for comparing different approaches to solving tasks in SDKs. Describes algorithm optimizations and limitations in architectural decision records.
Develops standards for documenting algorithmic complexity and API performance characteristics. Creates in-depth technical whitepapers on algorithm optimization for specific product use cases. Designs interactive performance benchmark visualizations for the developer portal.
Defines the policy for documenting performance and algorithmic complexity for all organizational APIs. Standardizes performance documentation format and integrates benchmarks into CI. Coordinates creation of comprehensive performance guides for all company products.
Understands basic data structures: arrays, lists, dictionaries for accurately describing APIs and interfaces. Knows main collections and can correctly document parameter types and return values. Uses data structure knowledge for creating clear diagrams and schemas in documentation.
Documents complex data structures in API references: nested objects, trees, dependency graphs. Creates data structure visualizations for technical guides and architectural documentation. Evaluates and describes data structure choice trade-offs in advisory documents.
Develops templates and standards for documenting complex data models and their relationships. Designs interactive data structure visualizations for developer portals and API Explorer. Creates in-depth technical guides on choosing and using data structures in projects.
Defines data model documentation standards for all organizational projects. Coordinates creation of a unified data structures knowledge base for developers and architects. Implements auto-generation of documentation from schema definitions and data models.
API Management
▼
Understands API documentation structure: endpoint descriptions, request parameters, response formats, error codes. Knows main tools: Swagger UI, Redoc, Postman. Can read and supplement existing API documentation.
Independently creates comprehensive API documentation based on OpenAPI/Swagger specifications. Documents authentication, rate limiting, pagination, versioning. Writes getting started guides and tutorials for API consumers.
Designs API documentation information architecture for complex products: multi-API portal, versioned docs, SDK references. Implements auto-generation from code with manual enrichment of descriptions and examples. Ensures consistency through style guide and linting.
Defines API documentation standards for the organization: templates, review processes, quality gates. Coordinates work of multiple technical writers on a large API portfolio. Implements documentation quality metrics (completeness, accuracy, freshness).
Understands why API versioning is needed and main approaches: URI versioning, header versioning, query parameter versioning. Knows semantic versioning principles. Can document API version in specifications.
Documents differences between API versions: changelog, breaking changes, migration path. Creates versioned documentation with version switcher. Describes deprecation policy and sunset timeline for legacy versions.
Develops documentation strategy for multi-version APIs: maintaining multiple versions simultaneously, migrating users. Creates migration guides with code diff examples and compatibility matrices. Automates changelog generation.
Defines organizational API versioning documentation standards: changelog templates, deprecation notices, partner communication plans. Ensures consistency of documentation versioning practices across all API products.
API Protocols
▼
Understands Server-Sent Events technology: unidirectional data stream from server to client. Knows the differences between SSE, WebSocket, and long polling. Can document SSE event format and fields (event, data, id, retry).
Creates SSE API documentation: event catalog, connection management, error handling, reconnection strategy. Writes connection code examples in JavaScript, Python, curl. Documents SSE usage best practices.
Documents complex SSE patterns: event sourcing, load balancing SSE connections, scaling strategies. Creates interactive SSE documentation: live event preview, playground. Ensures streaming API documentation coverage.
Defines streaming API documentation standards (SSE, WebSocket, gRPC streaming) for the organization. Ensures consistency in real-time communication documentation approaches across teams.
Understands WebSocket technology: full-duplex communication, handshake, frames. Knows differences from HTTP, SSE, long polling. Can document WebSocket events and message format for simple real-time APIs.
Creates WebSocket API documentation: connection lifecycle, message protocol, authentication, reconnection strategy. Writes code examples in JavaScript and Python. Documents error handling and rate limiting for WebSocket.
Documents complex WebSocket architectures: pub/sub patterns, room-based communication, binary protocols. Creates comprehensive real-time API documentation. Develops testing guides for WebSocket integrations.
Defines real-time API documentation standards for the organization. Coordinates a unified approach to documenting WebSocket, SSE, and gRPC streaming. Ensures developer experience for real-time integrations.
Application Security
▼
Understands main OWASP vulnerabilities and can document basic project security requirements. Knows security terminology for correctly describing authentication and authorization in API documentation. Creates simple security guidelines for developers within project documentation.
Documents project security architecture: threat model, security controls, compliance requirements. Creates secure development guides based on OWASP Top 10 for the development team. Describes security review and vulnerability management procedures in operational documentation.
Designs security documentation standards for the organization: threat models, security policies, compliance docs. Creates in-depth application security guides tied to specific product technologies. Implements automatic security documentation generation from security scanning tools.
Defines corporate security documentation standards for all organizational projects. Coordinates creation of a unified security knowledge base and compliance documentation repository. Implements documentation-driven security approach with automated freshness checks.
Architecture Governance
▼
Understands the purpose of Architecture Decision Records and their role in capturing architectural decisions. Knows the basic ADR structure (context, decision, consequences). Can find and read existing ADRs in the project repository.
Independently creates ADRs based on discussions with architects and developers. Maintains numbering, coherence, and relevance of records. Integrates ADRs into docs-as-code pipeline, ensuring publication on the developer portal.
Develops ADR process for the entire organization: templates, review rules, lifecycle statuses (proposed, accepted, deprecated, superseded). Helps architects formulate decisions clearly and argumentatively, reviews context and consequences.
Establishes corporate Architecture Decision Records practices: governance, integration with architecture review board, onboarding for new developers. Conducts ADR audits and ensures their relevance as the system evolves.
Architecture Patterns
▼
Understands basic Clean Architecture principles: separation into layers (entities, use cases, interface adapters, frameworks). Knows the dependency rule and dependency inversion. Can document layered application structure.
Documents Clean Architecture projects: describes purpose of each layer, dependency rules, code examples. Creates architecture decision records explaining Clean Architecture choices. Helps developers understand architectural boundaries.
Creates comprehensive Clean Architecture documentation for complex systems: mapping between business capabilities and architecture layers, testing strategies per layer, dependency injection configuration. Reviews code for compliance with architectural descriptions.
Standardizes approaches to documenting Clean Architecture in the organization. Creates reference implementations with detailed documentation. Ensures architecture documentation consistency when scaling teams.
Understands the fundamentals of Hexagonal Architecture. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Documents Hexagonal Architecture projects: describes ports, adapters, domain model, use cases. Creates architecture guides explaining design decisions. Helps developers understand boundaries between layers.
Creates comprehensive Hexagonal Architecture documentation: mapping business capabilities to ports, adapter implementation patterns, testing strategies. Ensures coherence between architecture docs and the codebase.
Standardizes documentation of architectural patterns (Hexagonal, Clean, Onion) in the organization. Creates reference documentation and template projects. Coordinates consistency of approaches across teams.
CI/CD
▼
Understands the purpose of CI/CD for documentation: automated building, validation, deployment. Knows the basic structure of a GitHub Actions workflow. Can run existing docs pipelines and interpret results.
Configures GitHub Actions for documentation pipeline: build, lint, link-check, deploy. Sets up workflows for PR preview environments. Uses actions for auto-generating documentation (API docs, changelogs).
Designs complex CI/CD pipelines for documentation: matrix builds for multi-version docs, conditional deploys, automated testing. Creates reusable workflows for multiple documentation projects. Optimizes build performance.
Defines CI/CD strategy for all documentation projects in the organization. Standardizes pipelines, manages shared runners and secrets. Implements advanced scenarios: scheduled builds, cross-repo triggers, automated content validation.
Clean Code & Refactoring
▼
Understands basic code quality metrics and their impact on creating clear documentation. Knows clean code principles and uses them for writing quality examples in documentation. Evaluates code readability when selecting snippets for technical guides.
Analyzes code quality of documented projects to determine documentation priorities. Uses linters and static analysis to automatically check code examples in documentation. Creates coding standards guides with emphasis on self-documenting code.
Designs a code quality metrics system that influences organizational documentation processes. Implements automatic validation of code examples in documentation through CI/CD pipeline. Develops self-documenting code standards to minimize the need for external documentation.
Defines the relationship between code quality metrics and documentation quality at the project level. Standardizes code quality analysis tools for documentation team needs. Implements automated code-documentation consistency checks in the CI process.
Cloud Providers
▼
Understands basic AWS services and can document simple infrastructure configurations. Knows core cloud architecture components for describing deployment processes in guides. Creates getting started documentation for setting up AWS environments for developers.
Documents project cloud architecture on AWS: services, networks, security groups with diagrams. Creates deployment and AWS service configuration guides for DevOps and developer teams. Describes cost optimization and scaling strategies in architectural decision records.
Designs cloud documentation standards for the organization: architecture diagrams, runbooks, IaC docs. Creates in-depth AWS Well-Architected Framework guides in the context of company products. Implements auto-generation of infrastructure documentation from CloudFormation/Terraform.
Defines corporate standards for documenting cloud infrastructure across all projects. Coordinates creation of a unified cloud architecture catalog with descriptions and compliance requirements. Implements documentation-as-code approach to infrastructure documentation management.
Code Review
▼
Understands basic code review principles and can evaluate code readability in documented projects. Knows key code quality criteria that help create accurate API and interface descriptions. Can identify discrepancies between code and existing documentation.
Participates in code review to verify technical documentation matches actual code. Evaluates quality of comments and docstrings in code, suggesting improvements for auto-generated documentation. Checks code examples in documentation for correctness and relevance.
Develops code documentation standards within the code review process: inline comments, docstrings, README. Reviews documentation PRs for style compliance and API coverage completeness. Creates checklists for reviewers to check documentation aspects of code.
Defines documentation-as-code review policy for the entire project and integrates checks into CI. Standardizes documentation review approaches in the team: templates, quality criteria, automated checks. Coordinates interaction between developers and technical writers in the review process.
Collaboration Tools
▼
Understands the InnerSource concept: applying open-source practices within a company. Knows the role of documentation in InnerSource: README, CONTRIBUTING, CODE_OF_CONDUCT. Can create basic documentation for internal projects.
Creates comprehensive InnerSource documentation: contribution guides, architecture overviews, getting started, API references. Helps projects become discoverability-friendly through quality documentation. Adapts open-source documentation best practices.
Designs documentation framework for the company's InnerSource program: standards, templates, quality requirements. Creates internal developer portal for InnerSource project discoverability. Trains teams on writing quality documentation.
Defines documentation strategy for InnerSource at the organizational level. Coordinates documentation for cross-team projects. Builds a culture of documentation through InnerSource practices, training, and incentives.
Concurrency & Parallelism
▼
Understands async/await and callback concepts for correctly describing asynchronous APIs in documentation. Knows main asynchronous programming patterns and can document Promise-based APIs. Creates simple async code examples for getting started guides.
Documents complex asynchronous APIs: streaming, WebSocket, event-driven interfaces with practical examples. Creates error handling guides for asynchronous code for developers. Describes concurrency and parallel execution patterns in architectural documentation.
Designs standards for documenting asynchronous APIs and event-driven architectures for the organization. Creates interactive playgrounds for testing async API calls in the developer portal. Develops in-depth guides on troubleshooting race conditions and async errors.
Defines standards for describing asynchronous patterns and concurrency across all organizational documentation. Coordinates a unified approach to documenting event-driven and stream-based APIs across teams. Implements automatic async code example generation from OpenAPI specifications.
Containerization
▼
Understands basic Docker concepts for documentation: running docs site locally in containers, Docker-based preview environments for documentation, basic docker-compose for docs toolchains. Follows team conventions for containerized documentation build systems.
Creates Docker environment documentation for projects: Dockerfile best practices, docker-compose configurations, multi-stage builds. Documents deployment processes using containers. Uses Docker to reproduce environments when writing documentation.
Documents complex container architectures: orchestration, networking, volume management, security best practices. Creates runbooks for Docker-based infrastructure. Automates documentation preview environments through Docker.
Standardizes approaches to documenting container infrastructure. Defines documentation templates for Docker-based projects. Implements containerized documentation pipelines for team scaling.
Git & Workflows
▼
Understands basic Git advanced features for technical writing: branching for documentation versions aligned with product releases, cherry-pick for porting doc fixes between version branches, conflict resolution in collaborative docs editing. Follows team conventions for docs-as-code repository structure.
Confidently uses Git for docs-as-code workflow: rebase, cherry-pick, squash, stash. Works with monorepo and multi-repo setups. Configures Git hooks for automatic documentation checks (pre-commit linting).
Designs Git workflow for the documentation team: branching strategy, release docs versioning, automated changelog generation. Works with Git submodules/subtrees for multi-repo docs. Optimizes Git performance for large documentation repositories.
Defines Git standards for all documentation projects in the organization. Automates processes through Git-based workflows: auto-publish, versioned releases, content approval. Trains authors on effective Git usage.
Understands the problem of storing large binary files in Git and the purpose of Git LFS. Knows which documentation files require LFS: images, diagrams, videos, PDFs. Can configure Git LFS for a documentation repository.
Effectively uses Git LFS in docs-as-code workflow: tracks binary files, manages storage quota, optimizes clone/fetch for CI. Documents LFS workflow for the team. Resolves common issues (missing files, bandwidth limits).
Designs documentation media content storage strategy: choosing between Git LFS, CDN, object storage. Optimizes pipeline for working with large documentation repositories. Configures LFS-compatible CI/CD for automated publishing.
Defines organizational standards for working with binary content in documentation. Manages LFS server and storage. Optimizes storage costs and transfer bandwidth for documentation projects.
GraphQL
▼
Understands basics of GraphQL schema design to write accurate API documentation. Reads and interprets GraphQL type definitions, queries, and mutations for documentation purposes. Follows team conventions for documenting GraphQL endpoints using tools like GraphQL Playground and schema annotations.
Creates comprehensive GraphQL API documentation: schema reference, query examples, mutation guides, error handling. Uses GraphQL introspection for auto-generating reference docs. Documents API usage best practices.
Documents complex GraphQL patterns: federation, schema stitching, custom directives, real-time subscriptions. Creates interactive GraphQL explorer for the developer portal. Develops migration guides during schema evolution.
Defines GraphQL API documentation standards for the organization. Creates templates and guidelines. Ensures documentation consistency when multiple teams work on federated GraphQL schemas.
gRPC
▼
Understands basics of gRPC & Protocol Buffers for writing accurate API documentation. Reads proto file definitions and service descriptions for documentation purposes. Follows team conventions for documenting gRPC service endpoints, message types, and streaming patterns.
Creates gRPC API documentation: service reference, message schemas, streaming patterns, error codes. Configures auto-generation of documentation from .proto files (protoc-gen-doc, buf). Documents proto style guide.
Documents complex gRPC patterns: bidirectional streaming, interceptors, load balancing, deadlines. Creates architecture docs for gRPC-based microservices. Develops migration guides for proto contract updates.
Defines gRPC/Protobuf documentation standards for the organization. Implements automated pipelines for proto docs. Ensures consistency when multiple teams work on shared proto contracts.
Integration Testing
▼
Understands the difference between unit and integration tests for documenting project testing strategies. Knows main integration testing tools and can describe the test execution process. Creates basic documentation for setting up test environments for developers.
Documents project integration testing strategy: tools, configurations, best practices. Creates integration test writing guides for APIs with examples and test fixtures. Describes CI/CD pipeline focusing on integration testing stages and requirements.
Designs integration testing documentation standards for the organization: templates, examples. Creates in-depth guides on testing distributed systems with practical scenarios. Implements automatic test documentation generation from test suites and CI configuration.
Defines corporate integration testing documentation standards for all projects. Coordinates creation of a unified integration testing knowledge base across teams. Implements documentation-driven testing approach with automated freshness checks.
Kubernetes & Orchestration
▼
Understands basic Kubernetes concepts and can document simple deployment configurations. Knows core K8s objects: Pod, Service, Deployment for describing infrastructure in guides. Creates getting started documentation for working with clusters for developers.
Documents project Kubernetes architecture: deployments, services, ingress, ConfigMaps with diagrams. Creates deployment and application management guides in K8s for the DevOps team. Describes troubleshooting procedures and common issues in operational runbooks.
Designs Kubernetes documentation standards for the organization: architecture guides, operational playbooks. Creates in-depth production-ready K8s guides: security, networking, monitoring, scaling. Implements auto-generation of documentation from Helm charts and Kubernetes manifests.
Defines corporate standards for documenting Kubernetes infrastructure across all projects. Coordinates creation of a unified K8s knowledge base with runbooks and troubleshooting guides. Implements documentation-as-code approach to infrastructure documentation management.
Logging
▼
Understands basic structured logging concepts for documentation: documenting logging standards and conventions, writing runbook sections for log analysis, understanding log schemas for operational documentation. Follows team conventions for logging documentation structure and style.
Documents project logging systems: formats, levels, correlation IDs, fields and their purposes. Creates troubleshooting guides using structured logs for the support team. Describes logging integration with monitoring and alerting in operational guides.
Designs observability documentation standards: logs, metrics, traces for the entire organization. Creates in-depth guides on configuring and using centralized logging for different platforms. Develops runbook documentation templates based on structured log analysis.
Defines corporate logging and observability documentation standards for all projects. Coordinates creation of a unified logging glossary and format reference for all teams. Implements auto-generation of documentation from logging configuration and schema definitions.
Metrics & Monitoring
▼
Understands the purpose of Prometheus and Grafana and can document basic metrics and dashboards. Knows metric types and their format for creating application monitoring reference guides. Describes basic monitoring setup in project operational guides.
Documents project monitoring systems: metrics, dashboards, alerts with descriptions and thresholds. Creates runbook documentation for incident response based on Grafana dashboards. Describes Prometheus integration with other observability stack components in architectural guides.
Designs operational documentation standards: runbooks, playbooks, monitoring guides for the organization. Creates in-depth observability stack configuration guides for various deployment scenarios. Implements auto-generation of documentation from Prometheus rules and Grafana dashboard JSON.
Defines corporate operational documentation and monitoring guide standards for all projects. Coordinates creation of a unified runbook repository with automatic updates from alerting rules. Implements documentation-as-code approach to operational knowledge management.
Microservices Patterns
▼
Understands the fundamentals of Microservices Decomposition. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Documents microservices architecture: service catalog, dependency maps, communication patterns (sync/async). Creates onboarding guides for new developers. Documents service contracts and integration patterns.
Designs a microservices landscape documentation system: automated service registry docs, event catalog, cross-service sequence diagrams. Ensures documentation reflects the actual system state through auto-generation.
Defines microservices documentation standards for the organization. Every service has a mandatory documentation set. Coordinates documentation of cross-cutting concerns: observability, security, deployment.
OOP & Design Patterns
▼
Knows basic design patterns and can correctly use their names in technical documentation. Understands the purpose of main patterns for accurately describing architectural decisions in API references. Creates simple pattern diagrams for architecture visualization in guides.
Documents design pattern usage in product architecture with examples and rationale. Creates architectural guides describing pattern choices and their trade-offs for developers. Develops a project pattern catalog with code examples and usage recommendations.
Designs architectural documentation standards with pattern descriptions at the organizational level. Creates in-depth whitepapers and ADRs on pattern application in the context of large-scale products. Develops interactive architectural pattern visualizations for developer education.
Defines standards for documenting architectural decisions and patterns for all company projects. Coordinates creation of a corporate pattern library with descriptions, examples, and decision criteria. Implements Architecture Decision Records as a standard documentation practice.
Understands basic OOP principles for correctly describing classes, interfaces, and hierarchies in API documentation. Knows encapsulation, inheritance, and polymorphism terminology for accurate use in technical texts. Creates simple UML diagrams for visualizing object models in documentation.
Documents complex object models describing patterns, interfaces, and class relationships. Creates architectural guides on OOP principle usage in project SDKs and libraries. Develops code examples demonstrating correct SOLID principle application for developers.
Designs object model and architectural decision documentation standards for OOP projects. Creates in-depth technical guides on applying design patterns in the product context. Develops interactive architecture and class diagram visualizations for the developer portal.
Defines architectural documentation standards for all OOP projects in the organization. Coordinates creation of a unified glossary of object design terms for all teams. Implements automatic documentation generation from annotated OOP code.
Prompt Engineering
▼
Uses AI to draft technical documentation, API references, and user guides. Formulates prompts with audience context (developer vs end-user) and style guidelines. Iterates on AI outputs to match documentation standards and tone.
Develops effective prompts for technical writing tasks: generation, rewriting, summarization, translation. Uses chain-of-thought, system prompts, output formatting. Creates repeatable prompt templates for the team.
Designs prompt pipelines for documentation automation: multi-step generation, validation chains, context injection. Defines quality metrics for AI-generated content. Optimizes prompts to reduce hallucination rate.
Defines prompt engineering strategy for the documentation team. Implements prompt version control and A/B testing of prompts. Establishes guidelines and trains the team on effective prompt engineering.
Relational Databases
▼
Understands basic PostgreSQL concepts for documentation: documenting database schemas and data models, writing query examples for API documentation, understanding table relationships for data flow diagrams. Follows team conventions for database documentation standards.
Documents project database schemas: tables, relationships, indexes, migrations with ER diagrams. Creates PostgreSQL guides for developers: best practices, conventions, common queries. Describes backup, restore, and maintenance processes in operational documentation.
Designs database documentation standards for the organization: schema docs, migration guides, runbooks. Creates in-depth PostgreSQL optimization guides with performance benchmarks and recommendations. Implements auto-generation of database documentation from DDL and migration scripts.
Defines corporate database documentation standards for all organizational projects. Coordinates creation of a unified database knowledge base with automatic updates from schema changes. Implements documentation-driven database management with versioned schema docs.
System Design
▼
Understands basic system design concepts: client-server, load balancing, caching, database types. Knows main architectural patterns. Can document high-level system architecture based on engineer descriptions.
Documents system design decisions: capacity planning, scalability patterns, failure modes. Creates architecture overviews for different audiences (engineers, management, new hires). Visualizes complex systems through clear diagrams.
Creates comprehensive system design documentation: NFR (non-functional requirements), capacity models, failure analysis, DR plans. Ensures coherence between system design docs, ADRs, and operational runbooks.
Defines system design documentation standards for the organization. Coordinates documentation of cross-cutting concerns: security, performance, reliability. Trains teams on documenting architectural decisions.
Unit Testing
▼
Understands basic unit testing concepts for documentation: sample code testing in docs, verifying code snippet accuracy, automated link and reference validation. Follows team practices for ensuring documented examples compile and produce expected output.
Documents project testing strategies: framework descriptions, conventions, coverage requirements. Creates unit testing guides for SDKs and APIs with practical examples. Includes code example testing in documentation CI pipeline to verify freshness.
Designs testing documentation standards for the organization: templates, best practices, automation. Creates in-depth TDD and testing pattern guides tied to specific products. Implements automatic validation of all code samples in documentation through unit tests.
Defines testing strategy documentation policy for all organizational projects. Standardizes testing guide formats and integrates documentation testing into the DevOps pipeline. Coordinates creation of a comprehensive testing knowledge base for all development teams.