Risks of Open Source Software: Licenses, Support and Testing
The risks of open source software go beyond cost: licenses, maintenance, support and quality. So test it yourself and give back to the community.
Architecture, Integration & Data Quality
Quality often depends less on individual features than on how things fit together: interfaces, legacy systems that have grown over years, data flows, and architecture decisions that either make a system testable or don't. This hub looks at software quality through the lens of architecture, integration, and data.
The articles and podcast episodes range from microservices, contract testing, and cloud migrations to technical debt, legacy systems, and architecture documentation, and on to test data management, synthetic test data, data warehouse testing, and assessing data quality. They are for people in architecture, development, and testing who think about quality while designing structures and data flows. The foundation page on integration testing offers a methodical starting point.
Foundations
Articles
Testability: Why Software Architecture Must Keep Evolving
Software architecture is a cornerstone of testability and has to keep evolving. That works best when testers and architects talk, ideally over coffee.
AI Programming Languages: Must Code Stay Human-Readable?
Should AI programming languages stay readable for humans? If AI writes the code, compilers and syntax may change. What that leaves for developers.
Additive Bias: Why Software Keeps Growing More Complex
Additive bias makes teams add features, code and test cases rather than remove any. Complexity and debt grow, and subtraction is the overlooked fix.
Test Data: First a Radical Cure, Then AI
Test data problems won't vanish with AI. First ask which data you really need, delete the rest and build a data architecture that works across systems.
Testing AI and Testing with AI: Rethinking Quality
AI in software testing helps with test cases, test data and error analysis. Testing AI systems means rethinking quality criteria such as data quality.
SAP Testing: Why Business Processes Set the Strategy
SAP testing starts with business processes and risk. PRACTICES UP covers eleven focus areas, and five data classes structure the test data.
Legacy Systems: Why Hardly Any Company Modernizes Them
Legacy systems grow through adapters and wrappers into technical debt. Modernization rarely pays off in the short term, so few companies dare to start.
Data Warehouse Testing: Assertions from Transformation Rules
Data warehouse testing needs more than plausibility checks. Assertions generated automatically from transformation rules make results checking reliable.
Types of Systems in Test Automation: From Desktop to Cloud
Types of systems, from desktop and client-server to web, mobile and data warehouse, decide how you automate tests and which tools fit at all.
Complicated Became Complex: Why We Work Agile Today
Software and its framework conditions have turned from complicated to complex. Agile working helps teams deal with what they cannot know in advance.
Test Dimensions for Integration Testing: Identifying Gaps
Test dimensions structure integration testing: objectives, test objects, level, test basis and typical errors. Mapping them reveals the gaps.
Object-Oriented Technology: Promises Only Partly Kept
Object-oriented technology promised big productivity gains and near-zero maintenance. Studies show partial success, with gains in reuse and portability.
Agile Technical Debt: Why Testers Must Keep It in Check
Agile technical debt is the measurable cost of poor code. Testers contain it with story reviews, code checks, continuous integration and done criteria.
Testing Cloud Services: Static Analysis and Dynamic Analysis
Testing cloud services takes two phases: static analysis checks requirements against the interface spec, dynamic analysis validates real responses.
Assessing Data Quality: Three Audits for Customer Databases
Assessing data quality in customer databases: three automated audits of schema, structure and content expose design flaws, invalid data and duplicates.
UML Metrics: Measuring Size, Complexity, and Quality
UML metrics count classes, states, and relationships across UML diagram types and measure a design's size, complexity, and quality before it is built.
Migration Testing: Proving the New System Matches the Old
With no specification, migration testing compares the new system with the old one. Seven steps, from code measurement to coverage, prove both match.
Test Center: Centralizing Test Activities Within the Company
A test center bundles scattered testing work in one internal or external unit. Four success factors: competence, staff, infrastructure and integration.
Testing Geoportals: Services and Clients per ISTQB Process
Testing geoportals means system and acceptance tests for services and clients. The ISTQB test process adds structure, from test concept to security.
Web Service Testing: Generate Requests, Verify Responses
Web service testing with WSDLTest: test data comes from the WSDL schema, pre-conditions shape requests, and post-conditions check responses.
Podcast Episodes
AI-Generated Code: Quality Assurance Must Keep Pace
More AI-generated code means more defects, and only about 30% of AI review comments help. Static analysis, test selection and reviews must scale too.
Branch Coverage: Full Coverage Still Lets Bugs Through
Even 100% branch coverage let an off-by-one bug slip through. Coverage is only as good as its assertions, and loops need several iterations.
API Testing: Agent-Optimized Design Cuts Token Costs
API testing depends on the protocol: REST, GraphQL, webhooks or MCP. It runs more stably than browser testing, and agent-friendly APIs save tokens.
Testing Complex Systems: Ship Small and Learn Fast
Testing complex systems: complex vs complicated, and why software behaves more like weather than a bridge. Safe-to-fail experiments help teams learn.
Holistic Engineering: Non-Technical Forces Shape Your Code
Holistic engineering treats career frameworks, delivery pressure and feared monoliths as architecture variables. Ignoring them makes change harder.
Architecture Fitness Functions: Making Decisions Testable
Architecture fitness functions turn design decisions into testable KPIs, so hard-to-reverse Type 1 decisions defend themselves against violations.
Barriers to Innovation: How Processes Paralyze Corporations
Barriers to innovation in German corporations start with excessive processes. AI won't pay off either while nobody cleans up decades-old data silos.
COBOL Unit Testing: Java Tests Run as Debugger Scripts
COBOL unit testing brings mainframe testing into SonarQube, Cucumber and Jenkins. A Java API turns the assertions into debugger scripts.
Chatbot Testing: Why Bugs Hide in Prompts and Retrieval
Chatbot testing has to look past the final answer into chunks, embeddings, prompts and fallback logic. How traceability makes these hidden bugs fixable.
Agentic Engineering: AI Accelerates Existing Principles
Agentic engineering is less about prompts than about the agent environment: your prompt is about 20 of 20,000 tokens. Cleanup agents keep quality up.
Blue Angel for Software: Transparency Instead of Top Marks
The Blue Angel for software asks for energy data, support for five-year-old hardware and free security updates. Certification takes about three months.
Mobile Security: From Unencrypted Calls to Overlay Attacks
From analog eavesdropping to overlay attacks on banking apps, mobile security has never stopped failing users in new ways.
Test Reporting: A 3x3 Matrix Covers Almost Every Need
Test reporting in 5 steps: Goal, position, forecast, data quality and automation. How reporting becomes a real management tool.
Design Patterns in Test Automation: Less Spaghetti Code
Test automation design patterns such as Page Object, Builder and Facade keep test code readable. DRY and YAGNI stop the framework from bloating.
Test Coverage: Process Mining Shows What Really Runs
Test coverage needs the right denominator. Process mining shows which workflows run in production, and the top 10 of 600 runs cover about 80 percent.
Startup Software Testing: Why Testability Comes First
Startup software testing begins with testability and customer focus, not formal processes. Outnumbered testers have to speak up, even to management.
Pekka Klärck: Why Robot Framework Has a Generic Core
Pekka Klärck began Robot Framework as his master's thesis in 2004. Over 80 companies now back its foundation, and its generic core fits mixed stacks.
Thermal Management Testing: Earlier with HiL and Virtual ECU
Thermal management testing for electric vehicles moves from the road to HiL and a virtual ECU. Faults show up earlier, yet a test run still takes days.
Consumer-Driven Contract Testing: Consumers Define the API
Consumer-driven contract testing with Pact checks what an API sends and what its consumers expect. If a contract breaks, the build fails before release.
Test Automation Strategy: Start with the Problem
A test automation strategy starts with the problem, not the tool. Map current and target state on the test pyramid; the gap is your scope of work.
Testing Wind Turbines: Lightning Only Strikes in the Field
Testing wind turbines means covering about 164 subsystems with simulators, hardware in the loop and field data, because lightning cannot be provoked.
Dynamic Analysis: Embedded Coverage on Real Hardware
Dynamic analysis on real hardware: embedded trace measures code coverage in integration testing without the timing side effects of instrumentation.
Teaching Software Testing: Students Need Real Complexity
Software testing is hard to teach at university because small exercises hide the benefit. Complex projects, TDD and testable architecture make it click.
Software Testing Value: Frame Quality in Business Terms
Software testing value gets lost when testers pitch defects. Revenue and user satisfaction make a stronger case, and domain knowledge matters more.
Cypress to Playwright: Migrate Critical Paths First
Switching test automation frameworks mid-product is messy, yet a Cypress to Playwright move works. Pricing forced it, AI translated the tests.
Developer Friendliness: Invest Time, Save Time
Developer friendliness costs time short term, saves it long term and makes teams happier. REST mocks and test interfaces show how it works.
Security by Design: Why Custom Encryption Adds Risk
Security by design starts with threat modeling any team can run, layered defenses and secure defaults. Security bolted on in the last 10% stays thin.
Synthetic Test Data from Schemas: GDPR-Compliant Testing
Synthetic test data from XML and JSON schemas is GDPR compliant, covers extreme values and finds bugs that anonymized production data misses.
Legacy Modernization: Why Missing Experts Are the Bottleneck
Legacy modernization usually stalls on missing subject matter experts. How RAG makes legacy code queryable and why working in slices lowers the risk.
Robot Framework: Keyword-Driven Testing for Any Technology
End-to-end across web, desktop, database and 3270 hosts: where Robot Framework earns its place, where web-only tools stop, and why it won't die soon.
Enterprise Software Testing Is About Configuration Impact
Enterprise software testing checks how configuration changes in SAP ripple through dependent processes. Why business users test mostly the happy path.
Microservices Testing at REWE: Fewer End-to-End Tests
Microservices testing at REWE: unit and API tests per service, few end-to-end tests on the money path, flaky tests in quarantine, production monitoring.
AI Audit: How the AI Assessment Matrix Structures Testing
An AI audit needs a yardstick. The TÜV AI Lab's AI Assessment Matrix maps test dimensions against the lifecycle, so assessors pick the relevant fields.
Migrating from Cypress to Playwright: The Real Effort
Migrating from Cypress to Playwright took a team over a year alongside daily QA. The main hurdles: session handling, request interception, legacy tests.
Risk-Based Testing in Practice: Cutting E2E Tests by Half
Which headline do you not want in tomorrow's paper? Risk-based testing starts with that question. One team cut its end-to-end tests by 50 to 60 percent.
UI Testing with Mocks: Test the Frontend Without a Backend
UI testing with mocked API responses checks the frontend as a full app, no backend needed. At Volkswagen, 280 tests run in under three minutes.
CI/CD Pipelines in Embedded C: Tests as a Safety Net
CI/CD pipelines for embedded C at Marquardt run on CMake, Google Test and generated mocks. Every bug fix starts with a test that reproduces the bug.
Code Readability: Why Some Code Is So Hard to Understand
Code readability depends on working memory, which holds about four chunks at once. Good naming, few arguments and no side effects respect that limit.
Accessibility Act: Blind Testers Find What Tools Miss
Accessibility testing can't be fully automated. Accessible components can still break once combined, and blind testers catch it with screen readers.
Software Analysis: Assessing an Inherited Ticket Shop
Software analysis of an inherited ticket shop: static analysis gave a first verdict in 1.5 days. Then a third of the code turned out to be a black box.
Shift Left vs Shift Right: You Don't Have to Pick One
Shift left parallelizes testing before go-live, shift right watches production. One insurer runs the same UI tests in both worlds. How that works.
Testing Data Processes: Expected Results from the Specification
Testing data processes works best with expected results generated from the business specification, since production data covers only about 70% of cases.
Business Analysts and Testers: Spotting Edge Cases Early
A business analyst who thinks like a tester spots edge cases before any code exists. A data warehouse project shows why testers should question specs.
Embedded Testing: How Far You Get Without the Hardware
Embedded testing starts before the hardware arrives. Why simulators fail at timing and bus protocols, and when real target hardware belongs in CI.
Form Testing: Model-Based Test Data via SMT Solver
Form testing for over 255 tax form variants across 16 states: an SMT solver derives valid test data from the model and exposes contradictory rules.
Documentation as Code: Treat Architecture Docs Like Code
Documentation as Code keeps architecture docs current: written in AsciiDoc, versioned in Git and built in the pipeline through continuous documentation.
Testing AI Systems: Determinism Decides the Test Strategy
Testing AI systems often boils down to one question: does the system behave deterministically? The answer decides whether classic methods suffice.
Replacing an In-House Test Framework with Robot Framework
Swapping a grown XML test monolith for Robot Framework took a year, a custom .NET remote library server and one developer freed from release duty.
Test Pyramid: How Test Layers Should Complement Each Other
The test pyramid is often misread: many unit tests, high coverage, still bugs. Why many JUnit tests in microservices are really integration tests.
Quality Requirements Call for an Adaptable Architecture
Separating functional and quality requirements sounds clean, but in practice the line blurs. Good architecture hides decisions and stays changeable.
Minimum Viable Test Strategy
Test strategy via workshop instead of a hundred-page document: How a collaborative format quickly brings teams to a common test picture.
Test Data Management: Testers Order Data Themselves
Five tools, manual transfer errors and no cross-system solution: that was test data management. A store concept changed the entire setup.
Zero Trust at Telekom: From 30 to 3 Identity Providers
Zero trust implementation starts with a shared definition, or everyone talks past each other. Telekom uses six aspects, from network to monitoring.
Tests from Rules: Generated Cases for Distributed Systems
Tests from rules replace hand-written cases: describe a system property once and a tool generates thousands. A shrinker traces failures to the cause.
Software Metrics: It’s the Context That Makes a Number Useful
Software metrics are often avoided because they reveal inconvenient truths. Yet a simple table can be enough to forecast testing effort and defects.
Making Architecture Decisions as a Team: Three Experiments
Teams often make architecture decisions while coding, without noticing. Double pairs, a long-term view and mob programming make them a team effort.
Domain Storytelling: Users and Developers Model Together
Domain storytelling is collaborative modeling: users tell stories from their domain, the team draws actors, work objects and activities as a diagram.
Monolith to Microservices: Cut Out Domains Step by Step
Moving from monolith to microservices works by cutting out domains step by step, backed by CI/CD and resilience tests. Greenfield rebuilds rarely last.
Sociable Unit Testing: Testing Use Cases All the Way to the Database
Why do teams write hundreds of unit tests, yet the software still doesn't run? Because isolated tests alone don't prove that a feature works.
C++ Core Guidelines: Ownership Is the Most Important Rule
The C++ Core Guidelines by Stroustrup and Sutter put ownership first: does code own a resource or only borrow it? Getting it wrong crashes programs.
Speech Recognition Testing: Every Fix Means Retraining
Speech recognition testing means testing a black box: every fix costs days of retraining. Golden test sets and generated variations find errors early.
Contract-Based Testing: Detecting Breaking Changes Early
Contract-based testing lets provider and consumer agree on a versioned contract. Breaking changes then surface in the CI pipeline before integration.