Engineering bewijs

Bz Info is niet alleen een portfolio. Het is een verifieerbaar productsysteem.

Deze pagina toont de technische logica achter het platform: webarchitectuur, NestJS backend, kwaliteit, tests, operatie, SEO, i18n en delivery discipline.

Husky pre-pushESLint + Prettierportfolio-api/test9 quality phasesmodule runners.reports output

Gegenereerde pagina’s

714

Statische pagina’s na toevoeging van expertise, tools en gelokaliseerde routes.

Actieve talen

Frans, Engels, Arabisch, Spaans, Duits en Nederlands met eigen routes.

Kwaliteitsketen

Typecheck + Build

Systematische frontendvalidatie voordat wijzigingen worden vastgezet.

Backend quality is module-owned.

Each serious module can expose its own perf, contract, unit, integration, E2E, smoke, security and mutation phases.

Systeemkaart

Een platform ontworpen als compleet product.

Het bewijs komt niet uit één pagina. Het komt uit het geheel: publieke site, API, admin, documentatie, tools, lokale content en kwaliteit.

01 · Visible

Public web

Next.js, localized routes, SEO, sitemap, expertise pages and documentation.

02 · Architecture

Backend API

NestJS API for contact, chatbot, analytics, communication and product workflows.

03 · Operations

Admin system

Future supervision for requests, conversations, logs, statistics and operations.

04 · Expansion

Tools lab

Developer packs, scripts, transactional SMS gateway and local AI workstation.

Backend bewijs

De backend wordt behandeld als productruggengraat.

Het doel is modules, contracten, validatie, domeinflows, veiligheid en integraties gestructureerd te tonen.

NestJS

Modular architecture

Modules, services, DTOs, guards, validation and maintainable API contracts.

Prisma

Controlled persistence

Models, transactions, constraints and clear separation between domain and storage.

Realtime

Live flows

Chat, support, notifications and admin interfaces connected to real system state.

Communication

Email, SMS and notifications

Transactional channels designed with limits, logs, security and precise usage.

HTTP request

Controller receives a public operation through a documented route.

DTO validation

class-validator, Swagger metadata and ValidationPipe must stay aligned.

Guard / auth

Access rules, JWT context, throttling and role checks protect the boundary.

Service decision

Business rules are isolated, testable and protected by explicit branches.

Prisma / storage

Transactions, constraints and persistence shape are verified by tests.

Reports

Schemathesis, smoke, ZAP, k6 and Stryker expose behavior from outside.

Backendmethodiek

Een progressieve methode die over frameworks heen werkt.

NestJS, Spring Boot, Python, Go of .NET: begrijpen, vastzetten, verbeteren, meten, hardenen en documenteren.

Reconnaissance

Routes, DTOs, guards, services, database access, fouten en publieke contracten lezen.

Het systeem begrijpen voordat het verandert.

Lichte refactor

Verantwoordelijkheden verduidelijken zonder het product te herschrijven.

Schuld verminderen zonder risicovolle migratie.

Basistests

Bestaand gedrag vastzetten met eenvoudige maar nuttige tests.

Een veiligheidsnet creëren voor diepere correcties.

Diepe tests

Branches, fouten, grenzen, transacties, null, undefined en uitzonderingen testen.

Blinde vlekken aanvallen die oppervlakkige tests missen.

Integration & E2E

Grenzen tussen API, auth, database en services valideren.

Gedrag buiten isolatie bewijzen.

Performance

Latency, concurrency, DB-contention, N+1, throttling, memory en trage paden meten.

Vinden wat breekt onder echte belasting.

Contract testing

OpenAPI en Schemathesis tegenover echt gedrag zetten.

DTOs, Swagger, ValidationPipe en gedocumenteerde responses corrigeren.

Runtime security

Smoke checks, ZAP, logs en runtimeverificatie toevoegen.

Het systeem observeren zoals het echt draait.

Mutation testing

Coverage is niet genoeg; Stryker meet of assertions echt beschermen.

portfolio-api/test

Module-by-module quality factory

Each backend module owns the same quality surface, from contract checks to mutation testing, with a dedicated global runner and local README.

01-perf

Load, latency and concurrency baseline.

02-schemathesis

OpenAPI contract attack against real endpoints.

03-unit

DTOs, services, guards, modules and branch decisions.

04-integration

Database, providers and cross-service boundaries.

05-e2e

Real API flows through the application surface.

06-smoke

Runtime availability and critical path sanity checks.

07-zap

Basic exposed security signals.

08-mutation

Stryker mutation strength and test robustness.

Sample modules already shaped with this convention

admin-authadmin-dashboardadmin-supportaudit-logschatchatbotcontacthealthleadsmonitoringnotifications

test/<module>/
├── 01-perf
├── 02-schemathesis
├── 03-unit
├── 04-integration
├── 05-e2e
├── 06-smoke
├── 07-zap
├── 08-mutation
├── scripts/run-<module>-global.sh
└── README.md

bash

Global module runner

One command can run the module quality chain with explicit toggles.

MODULE_NAME="admin-auth"RUN_ADMIN_AUTH_SCHEMATHESIS="${RUN_ADMIN_AUTH_SCHEMATHESIS:-true}"RUN_ADMIN_AUTH_SMOKE="${RUN_ADMIN_AUTH_SMOKE:-true}"RUN_ADMIN_AUTH_UNIT="${RUN_ADMIN_AUTH_UNIT:-true}"RUN_ADMIN_AUTH_INTEGRATION="${RUN_ADMIN_AUTH_INTEGRATION:-true}"RUN_ADMIN_AUTH_E2E="${RUN_ADMIN_AUTH_E2E:-true}"RUN_ADMIN_AUTH_MUTATION="${RUN_ADMIN_AUTH_MUTATION:-true}"

bash

Schemathesis contract attack

OpenAPI is fetched from the running API, then attacked in Docker.

SCHEMA_FETCH_URL="${SCHEMA_FETCH_URL:-http://localhost:4002/api/docs-json}"SCHEMATHESIS_BASE_URL="${SCHEMATHESIS_BASE_URL:-http://host.docker.internal:4002}"SCHEMATHESIS_PATH_REGEX="${SCHEMATHESIS_PATH_REGEX:-^/api/v1/admin/auth/(login|refresh|logout|me)$}"docker run --rm --add-host=host.docker.internal:host-gateway \  ghcr.io/schemathesis/schemathesis:stable run openapi-admin-auth.json

json

Stryker mutation gate

Mutation score is a hard quality threshold, not a vanity metric.

{  "testRunner": "jest",  "mutate": ["src/modules/admin-auth/**/*.ts"],  "coverageAnalysis": "perTest",  "thresholds": {    "high": 100,    "low": 100,    "break": 100  }}

javascript

k6 health baseline

Performance tests expose latency and failure-rate risks outside unit isolation.

export const options = {  thresholds: {    http_req_failed: ["rate<0.01"],    checks: ["rate>0.99"],    "http_req_duration{endpoint:health}": ["p(95)<250", "p(99)<500"],  },};

Tool → risico

Elke tool valt een andere risicocategorie aan.

Kwaliteit is geen verzameling logo’s. Elke stap heeft een reden en dekt een andere hoek.

TypeScript

Statische fouten

Detecteert type-inconsistenties vóór runtime, vooral in DTOs, services en contracten.

Unit tests

Fragiele businessregels

Zetten regels, branches, fouten en geïsoleerde edge cases vast.

Integration tests

Onzichtbare grenzen

Controleren interacties tussen services, transacties, database en dependencies.

E2E tests

Onvolledige API-flows

Valideren echte flows van endpoint tot verwacht productgedrag.

Load en concurrency

Toont latency, locks, N+1, contention en gedrag dat geïsoleerde tests missen.

Schemathesis

Verkeerd OpenAPI-contract

Toont verschillen tussen Swagger, DTOs, ValidationPipe, HTTP-statussen en responses.

ZAP

Runtime-oppervlak

Vindt basisveiligheidssignalen zichtbaar van buitenaf.

Stryker

Zwakke tests

Bewijst of de testsuite gedragsmutaties detecteert.

Vertrouwensmodel

Vertrouwen groeit wanneer meerdere risico’s worden aangevallen.

Deze grafiek is een didactisch model, geen wetenschappelijke statistiek.

Static

20%

De code compileert en duidelijke fouten verminderen.

Unit

38%

Belangrijke businessbeslissingen worden vastgezet.

Integration

55%

Service/database/API-grenzen worden veiliger.

E2E

68%

Echte flows worden end-to-end gevalideerd.

Contract

80%

Het publieke contract wordt automatisch aangevallen.

Runtime

88%

Performance, smoke en runtime security voegen realiteit toe.

Mutation

95%

De testsuite bewijst dat ze gevaarlijke wijzigingen detecteert.

Quality pipeline

Kwaliteit is een keten, geen decoratie.

Elke stap vermindert een soort risico: typing, contract, gedrag, runtime, veiligheid of testrobuustheid.

Static confidence

Check typing, formatting, conventions and obvious errors before runtime.

TypeScriptESLintPrettierBuild

Behavior confidence

Test business decisions, integrations and end-to-end user paths.

UnitIntegrationE2ESmoke

Contract confidence

Attack API contracts and verify that documentation reflects real behavior.

OpenAPISchemathesisSwaggerDTO validation

Hardening confidence

Actively look for weaknesses instead of stopping at a green build.

StrykerZAPk6Audit logs

Wat dit bewijst

De waarde zit in herhaalde discipline.

Deze pagina toont een methode: structureren, controleren, documenteren, lokaliseren, meten en refactoren.

Readable architecture

Pages, content, components and routes are separated to stay maintainable.

Real refactoring

Oversized files are split instead of being accepted as silent debt.

Verifiable SEO

Sitemap, canonical, hreflang and localized routes are treated as public contracts.

Proof through product

The site itself demonstrates the expected level: content, UI, architecture and validation.

Bruikbaar bewijs

Een technisch gesprek kan starten vanuit concreet bewijs.

Voor een backendmissie, technische recovery of productplatform is deze pagina een technisch startpunt.

Bespreek de vraag Bekijk documentatie