Testing
Load testing is one of those disciplines where the ecosystem gap between runtimes is painfully visible. k6 runs JavaScript, Locust runs Python, Gatling runs Scala. If you are a .NET shop writing C# all day, reaching for a Python-based tool to test your ASP.NET service means learning a
Testing
Keyboard and screen reader testing is the part of accessibility work that most teams skip or do poorly. The reason is usually practical: it requires learning new tools, new interaction patterns, and it can't be fully automated with the same confidence as color contrast or missing labels. But
Testing
.NET Minimal APIs strip away the controller ceremony and put your endpoint logic directly in delegates. That's a win for readability, but it shifts how you think about testing. Controllers gave you a natural seam — test the controller class, mock its dependencies. Minimal APIs push you toward two
Testing
Most ML projects have zero tests for their scikit-learn pipelines. The model "works" if it trains without crashing and the accuracy metric looks reasonable. But this leaves a class of bugs invisible: * A custom transformer that silently drops rows * A Pipeline that applies preprocessing in the wrong
Testing
Architecture violations are silent killers. A domain entity that imports an EF Core context, a service class that directly instantiates a repository, a controller that contains business logic — none of these blow up at compile time. They accumulate quietly until the codebase becomes a tangle that no amount of refactoring
API Testing
The hardest bugs to find with manual testing are the ones you don't think to test. You write tests for the happy path, a few expected error cases, and maybe some edge cases you've burned by before. But the input space of a real API is
Monitoring
Web performance monitoring tools have converged on similar feature sets at the surface level. Every major platform does uptime checks, transaction monitoring, and some form of alerting. The differences that matter for real teams are in the details: agent network coverage, transaction monitoring quality, load testing capability, and pricing transparency.
AI-powered QA automation for developers and engineering teams.
Synthetic monitoring runs scripted checks against your application continuously, simulating what real users do. The word "synthetic" distinguishes it from real user monitoring (RUM), which captures data from actual user sessions. Synthetic monitoring runs whether or not real users are active — it's the active probe, not
Property-based testing for APIs works like this: instead of writing POST /users with {"name": "Alice"} and checking the response, you define what properties the API should always satisfy, and let the test tool generate hundreds of inputs automatically. Schemathesis does exactly this for REST APIs
Manual API tests cover the happy path and a handful of error cases you thought to write down. Property-based testing covers the space you didn't think about — and that's exactly where real bugs live. Schemathesis is a Python-based tool that reads your OpenAPI (or
LoadView is Dotcom-Monitor's load testing product. The distinguishing feature: it uses real browsers — actual Chrome instances — rather than simulated HTTP traffic. That distinction matters more than it might seem, and it's worth understanding before you design your first load test. Why Real Browsers for Load
Dotcom-Monitor has a lot of surface area. The platform covers uptime monitoring, full browser checks, transaction monitoring, and load testing — and the UI reflects all of that. If you try to understand everything before running your first check, you'll be reading documentation for an hour before monitoring
* Use the expand/contract pattern: never rename or drop in a single migration * Test backward compatibility by running old app code against the new schema before cutover * Shadow tables let you verify data integrity without touching production reads/writes * Index migrations must be tested for lock acquisition time, not just
Schema-driven testing uses API specifications — OpenAPI, JSON Schema, AsyncAPI — as executable contracts. Instead of writing tests manually, you derive them from the spec. This catches structural bugs, breaking changes, and edge cases before they reach production, often without writing a single test by hand. Key Takeaways A schema is
Dockerfiles are code. Treat them like code. Use hadolint to catch anti-patterns at write time, container-structure-test to verify what your image actually contains, and layer inspection to keep builds lean and fast. This guide walks through a practical testing pipeline for Dockerfiles from lint to CI enforcement.
ScalaTest is the most widely used testing framework for Scala, offering multiple spec styles to match different team preferences. This post covers when to use FlatSpec, FunSuite, and WordSpec, how to write expressive matchers, manage shared fixtures, tag tests for selective runs, and speed things up with parallel execution. ScalaTest
Docker networks and volumes are often taken for granted in test setups, but they're the source of subtle bugs that only appear in multi-container environments. This guide covers how to test network connectivity between containers, validate volume behavior, and catch data persistence issues before production. Why Network
ScalaCheck brings Haskell's QuickCheck to the JVM, leveraging Scala's type system and functional programming features. This deep dive covers advanced Gen combinators, Arbitrary instances, stateful Commands testing, and integration patterns with Scala's major test frameworks. ScalaCheck Architecture ScalaCheck is built around three core concepts:
ScalaCheck's basic API — forAll, Gen.choose, Arbitrary — covers most property-based testing needs. But real production code involves domain types, complex constraints, and stateful systems. This guide covers the advanced ScalaCheck features that handle those cases: custom generators with combinators, custom Shrink instances, and the Commands API for