Active Projects

MI-M-T

Under Construction

testanalytic & testplan & testexec & projectreport — integrated test management and project reporting platform. Architecture: PostgreSQL · REST + JIRA adapters · React.js frontend · decoupled backend modules.

Detailed project documentation is not publicly available at this stage. The entity model and architecture overview below reflects the system design.

Architecture

PostgreSQL · REST API · JIRA adapters · React.js · Microservices

Functional Domains

TestImpuls
Requirement Initiative Functionality

Requirements and backlog management. Captures business intent: requirements, initiatives, and functional decomposition.

Demo →
TestAnalyticals
TestTarget TestCasePackage TestDataClass

Test analysis layer. Bridges requirements to executable test cases via test targets and structured test data classification.

Demo →
TestExecutiveDeployment
TestCase TestSet TestDataConfig TestEnvironment TestEnvironmentVar

Execution management. Test cases, sets, data configurations, and environment variables for structured deployment.

Demo →
IssueTracking
Issue

Defect and issue lifecycle. Linked to test cases, requirements, and functionality — full traceability chain.

Demo →
Reporting
TestRun TestCaseResult Report

Execution results and reporting. Aggregates run outcomes into structured reports for project stakeholders.

Demo →

15 entities  ·  5 domains  ·  Detailed project documentation is not publicly available at this stage.

Entity Model — classDiagram

classDiagram direction LR namespace TestImpuls { class Requirement { +title: String +description: String } class Epic { +title: String +priority: String } class Functionality { +name: String +scope: String } } namespace TestAnalyticals { class TestTarget { +name: String +type: String } class TestCasePackage { +name: String +strategy: String } class TestDataClass { +name: String +schema: String } } namespace TestExecutiveDeployment { class TestCase { +title: String +steps: String } class TestSet { +name: String +scope: String } class TestDataConfig { +name: String +values: String } class TestEnvironment { +name: String +type: String } class TestEnvironmentVar { +key: String +value: String } } namespace IssueTracking { class Issue { +title: String +severity: String +status: String } } namespace Reporting { class TestRun { +startedAt: DateTime +status: String } class TestCaseResult { +verdict: String +actual: String } class Report { +title: String +summary: String } } Requirement "1" --> "*" Epic : contains Epic "1" --> "*" Functionality : decomposes Functionality "1" --> "*" TestTarget : maps to TestTarget "1" --> "*" TestCasePackage : organizes TestCasePackage "1" --> "*" TestDataClass : uses TestCasePackage "1" --> "*" TestCase : generates TestCase "*" --> "*" TestSet : grouped in TestCase "1" --> "*" TestDataConfig : parameterized by TestEnvironment "1" --> "*" TestEnvironmentVar : defines TestSet "*" --> "*" TestEnvironment : runs in TestCase "*" --> "*" Issue : raises Functionality "*" --> "*" Issue : traced by TestSet "1" --> "*" TestRun : executes as TestRun "1" --> "*" TestCaseResult : produces TestRun "1" --> "*" Report : generates click Requirement href "/projects/mi-m-t/testplan/" _self click Epic href "/projects/mi-m-t/testplan/" _self click Functionality href "/projects/mi-m-t/testplan/" _self click TestTarget href "/projects/mi-m-t/testanalytic/" _self click TestCasePackage href "/projects/mi-m-t/testanalytic/" _self click TestDataClass href "/projects/mi-m-t/testanalytic/" _self click TestCase href "/projects/mi-m-t/testexec/" _self click TestSet href "/projects/mi-m-t/testexec/" _self click TestDataConfig href "/projects/mi-m-t/testexec/" _self click TestEnvironment href "/projects/mi-m-t/testexec/" _self click TestEnvironmentVar href "/projects/mi-m-t/testexec/" _self click Issue href "/projects/mi-m-t/projectreport/" _self click TestRun href "/projects/mi-m-t/projectreport/" _self click TestCaseResult href "/projects/mi-m-t/projectreport/" _self click Report href "/projects/mi-m-t/projectreport/" _self

15 entities across 5 functional domains. Scroll horizontally on narrow viewports.

Cooperations

Long-standing institutional, academic, and industry cooperations bridging analytical and engineering domains.

Academic & Research

RCMT — CTU Prague

Precision Engineering · Thermal Compensation

Research cooperation with the Research Centre of Manufacturing Technology at Czech Technical University Prague. Focus: thermal deformation compensation algorithms for precision CNC machining, fine measurement, and calibration.

rcmt.cvut.cz ↗

FemCalc

Finite Element Method · Engineering Simulation

Cooperation on FEM model development and practical engineering simulation applications. FemCalc provides web-accessible FEM calculation service, enabling simulation without on-premise solver infrastructure.

femcalc.azurewebsites.net ↗

Technology & Software

24U s.r.o.

Software Development · Quality Assurance

Core partnership for software testing strategy, test analysis, and QA methodology. 24U: Claris Platinum Partner, dedicated QA team, 100+ tested projects, 500+ releases across 10+ countries.

24u.cz ↗
T.

Shaddack / Improwis

Hardware · Low-level Systems · Reverse Engineering

T. "Shaddack" K.J. is a close collaborator and part of the wider MIM2000 team. Improwis.com hosts a technical project portfolio of hardware hacking, entropy generation, COM/serial protocol adapters, DMM reverse engineering, and low-level systems work — complementary capability reference to MIM2000's analytical and testing services.

improwis.com/projects ↗

Full partner profiles — including extended bios and advisory roles — are available in the Technology Partners section of the Contacts page.

Advisory Services

Bridging the gap between intention and execution — from process maturity to test architecture.

Process Maturity and Result Reliability — CMMI and TMMi

A common industry misconception positions Waterfall and Agile as ideological opposites. At a behavioural level, the conflict is real. But at a deeper level, both are instances of process execution, and the quality of outcomes from both is governed by the same underlying variable: process maturity.

Capability Maturity Model Integration (CMMI) provides a framework for measuring and improving organisational process maturity across the full software development lifecycle. Its five maturity levels — Initial, Managed, Defined, Quantitatively Managed, Optimising — describe the trajectory from ad-hoc execution towards systematic, self-improving processes.

Test Maturity Model Integration (TMMi) is the complementary framework for testing processes. Where CMMI covers the full SDLC, TMMi applies the same maturity-level structure exclusively to testing — from initial state (testing as a chaotic afterthought) to Level 5 (defect prevention as the primary testing objective). TMMi and CMMI are explicitly designed to be used together.

The causality chain: process maturity → process predictability → result reliability. For MIM2000 advisory engagements, the CMMI/TMMi lens is applied diagnostically: we assess where a client's processes sit on the maturity scale, identify specific process areas causing quality or timeline variance, and recommend targeted improvements. The goal is measurable reduction in rework cost, not certification for its own sake.

References: CMMI Institute, TMMi Foundation (R1.2), ISO/IEC 15504.

UML — The Best Standard That Cannot Guarantee Understanding

The Unified Modeling Language (UML 2.x, ISO/IEC 19501) is the most comprehensive notation for software system modelling ever standardised — fourteen diagram types covering structural, behavioural, and interaction views. No other notation achieves this breadth.

The fundamental paradox: UML is a formal visual language with a defined grammar. Conforming to that grammar is verifiable. Understanding the model conveyed is not. A sequence diagram can be syntactically perfect and simultaneously convey four completely different intended behaviours to four readers. Grammar correctness does not guarantee semantic consensus.

This matters directly in test analysis: a UML sequence diagram handed to a test analyst as the "requirements specification" is frequently a Rorschach test. Each analyst reads their own system assumptions into the gaps the notation does not fill. The result is test cases that test the analyst's mental model, not the intended system behaviour.

UML diagrams are coordination artefacts, not truth artefacts. Every diagram requires an accompanying written narrative that makes explicit the decisions the notation leaves implicit. Without the narrative, formal grammar creates false confidence in shared understanding.

References: Fowler — UML Distilled (3rd ed.); Rumbaugh, Jacobson, Booch — UML Reference Manual (2nd ed.); ISO/IEC 19501:2005.

SW Testing Services — Advanced V-Model and Test Architecture

The V-model maps each development phase to a corresponding testing phase. The advanced V-model extends this with explicit artefact dependencies and a Test Architecture layer — the engineering discipline of designing the test system itself.

Development Phase Test Phase MIM2000 Service
Business RequirementsAcceptance TestingTest Analysis
System RequirementsSystem TestingTest Analysis + Test Design
Architecture DesignIntegration TestingTest Design + Test Architecture
Detail DesignComponent TestingTest Design + Test Data
ImplementationUnit TestingTest Deployment + Execution

Test Architecture decisions: what to test at what level, with what tooling, and with what data — aligned to the overall IT project architecture. Key areas: test scope per level, boundary conditions between test levels, test data strategy (live subset vs mocked vs generated), environment topology, automation boundary.

Test Automation — Advantages and Limitations

Automate at API/service layer first — the most stable contract. UI automation only for critical user journeys with stable selectors. Never automate exploratory testing: the value is the human cognitive engagement. Automated tests can pass while the system is wrong if assertions or scope are incorrect — false confidence is more dangerous than no automation.

→ Testing & Engineering Blog — field notes by Petr Žemla, CEO & CTO

Solution Architecture

Architectural decision support, technology stack selection, integration pattern design, and scalability assessment. Bridging the gap between business requirements and technical implementation feasibility.

Detailed content in preparation

Raw Dev Case Studies

Unpolished, brutally honest technical case studies from real projects. No marketing gloss.

MIM2000 internal case studies — in preparation