Martin Kalema
Python
SQL
Data Wrangling & Cleaning: 9/10
Reproducibility & Notebook Hygiene: 8/10
Business Insight & Impact: 6/10
Active 27 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Roles
Overview
Technical skills
Python
SQL
Python
FastAPI
SQLAlchemy
Pydantic
Asyncio
Alembic
Uvicorn
Databases
PostgreSQL
ElasticSearch
Apache Iceberg
Trino
Apache Kafka
MongoDB
AI/ML
Pandas
Airflow
Senior Data Scientist
Confidence: Medium Data Engineer
A senior data engineer specializing in robust, production-grade batch ETL and data platform work with strong system and operational thinking. The strongest proven skill is reliable schema-driven ETL and replayable publication pipelines as implemented in ingestion/batch/pipeline/validation.py, trino_loader.py and the ClickHouse publication and retention workflow. Public code shows limited formal statistical analysis and no evidence of large-scale model training pipelines or MLOps deployment of predictive models.
Statistical Rigor
2/10
Correct use of statistics
Very little formal statistical inference or hypothesis testing is present; ML evaluation exists but not rigorous statistical treatment or uncertainty quantification.
Evidence
model-abliteration/notebooks/abliterate.ipynb
model-abliteration/obliteratus/adaptive_defaults.py
ingestion/batch/pipeline/validation.py
Data Wrangling & Cleaning
9/10
Preparing and cleaning data
Strong, production-minded data wrangling and cleaning with schema-driven validation, quarantine, exact-replay, lineage and provenance across R2/Iceberg/Trino and careful error handling.
Evidence
ingestion/batch/pipeline/validation.py
ingestion/batch/pipeline/trino_loader.py
ingestion/batch/pipeline/workflow.py
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Some notebook-driven analysis and operational metrics appear, but exploratory plots and written data-storytelling are limited compared with engineering work.
Evidence
model-abliteration/notebooks/abliterate.ipynb
apps/api/service.py
Predictive Modeling
3/10
Building models that predict
Model surgery and evaluation tooling exist, but there is no clear evidence of repeatable model training experiments, rigorous cross-validation, or production model deployment pipelines.
Evidence
model-abliteration/obliteratus/abliterate.py
model-abliteration/requirements.txt
Business Insight & Impact
6/10
Turning analysis into business value
Business intent is clear and linked to operational checks and API surfaces; the code maps metrics and readiness to product questions, though formal cost-of-error analysis is limited.
Evidence
apps/api/service.py
apps/api/operational_check.py
orchestration/daily_schedule.py
Reproducibility & Notebook Hygiene
8/10
Clean, repeatable analysis
High reproducibility and hygiene: extensive automated tests, CI workflow, pinned deps, reproducible synthetic generator and clear bootstrap scripts and runbooks.
Evidence
tests/
model-abliteration/requirements.txt
clean-architecture-ddd-python/.github/workflows/ci.yml
Expertise
Big Data• Senior
Data Warehouse• Senior
Streaming• Middle
Data Science• Middle
Industries
Energy & Utilities• Senior
Technologies
Python• since 2023 • Senior
SQL• Senior
PostgreSQL
Airflow
Apache Iceberg
Pandas
ElasticSearch
Asyncio
Trino
Recommendations
- Design and implement production ETL and lakehouse-to-serving workflows, including versioned publication, retention and exact-replay logic for complex time-series datasets.
- Build data-platform components that require schema-driven validation, provenance, and test-driven integrations with Trino/Iceberg and object-store backends.
- Develop resilient service-level APIs and operational readiness tooling that expose governed metrics and bounded operational probes.
- Collaborate on streaming ingestion prototypes using Spark Structured Streaming and checkpointed consumers where selective delivery and checkpointing matter.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
Backend Python engineer (senior) with a strong emphasis on resilient service patterns and careful database schema design. The strongest proven skill is building reliability primitives and testing them thoroughly, as demonstrated by the comprehensive circuit-breaker tests in tests/infrastructure/test_circuit_breaker.py and the deliberate PostgreSQL schema constraints and indexes in migrations/versions/20260712_000001_current_schema.py. There is limited public evidence of deployment automation, Kubernetes-level ops, multi-service runtime contracts, or production infra manifests in the analyzed human-authored files.
API Design
3/10
How well APIs are designed
API-level design and CQRS wiring are present but explicit public API versioning, idempotency headers and documented error contract artifacts are not visible in the human-authored files examined.
Evidence
clean-architecture-ddd-python/src/container.py: composition root wiring command and query handlers (CQRS separation noted in module docstring)
Data Layer & Database
8/10
Working with databases
Strong schema design and database constraints with index tuning and postgres-specific checks; migration shows deliberate data-integrity and performance choices.
Evidence
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: rich set of CHECK constraints, partial indexes, trgm GIN indexes and explicit PostgreSQL dialect guard
Scalability & Performance
5/10
Handling load and speed
Some scalability and performance work is evident via DB indexing and resilience primitives, but there is little direct evidence of measured tuning, caching-invalidation strategies or load-test artifacts in the human-authored files examined.
Evidence
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: indexes and partial indexes for query patterns
clean-architecture-ddd-python/tests/infrastructure/test_circuit_breaker.py: tests for concurrency and probe-limiting indicating operational resilience thinking
System Architecture
5/10
Overall system structure
Clear composition root and dependency-injection patterns show deliberate module boundaries and CQRS separation, but full service decomposition, inter-service contracts, and runtime degradation strategies are not visible in the inspected human-authored files.
Evidence
clean-architecture-ddd-python/src/container.py: dependency-injector composition root and wiring comments (CQRS)
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: schema boundary decisions reflecting domain separation
Security & Auth
2/10
Protecting data and access
Basic input hygiene and integrity constraints are enforced at the DB layer but explicit auth/authz, token lifecycle, secrets handling, or defense-in-depth patterns are not evidenced in the human-authored files analyzed.
Evidence
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: email normalization and regex checks, identifier pattern constraints
Reliability & Observability
8/10
Stability and monitoring
Strong reliability and observability focus demonstrated by a comprehensive circuit-breaker implementation and rich tests for timeouts, half-open probing, metrics and concurrent behavior; logging and structured logger imports are present in composition wiring.
Evidence
clean-architecture-ddd-python/tests/infrastructure/test_circuit_breaker.py: extensive tests covering deadlines, call timeouts, half-open probing, sliding-window failure rates and concurrency
clean-architecture-ddd-python/src/container.py: imports and wiring for logging adapters (JsonLogger / LoggerFactory) indicating observability integration
Expertise
Python• Senior
Microservices & API Architecture• Senior
Databases & Vector Storage• Senior
Messaging & Real-time• Middle
Industries
Energy & Utilities• Senior
Technologies
SQLAlchemy
FastAPI
Apache Kafka
Pydantic
Uvicorn
Alembic
Recommendations
- Develop resilient, domain-driven FastAPI services with strong DB schema guarantees and CQRS patterns (command handlers, unit-of-work) using the existing container composition root.
- Implement event-driven integrations and operational tooling for message delivery and DLQ handling leveraging the existing Kafka/aiokafka imports and outbox/inbox patterns.
- Own data-layer work that requires strict correctness: schema migrations, DB constraints, partial indexes and read-side performance tuning.
- Build library-level resilience features (circuit breakers, timeouts, probe-limiting) or test harnesses that exercise concurrency and reliability edge cases.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: Medium Generalist
Backend engineer with production-minded systems design experience at a middle level, strongest at careful schema and reliability engineering. The most proven skill is designing and validating production-grade PostgreSQL schemas and defensive constraints, evidenced by the migration file creating indexed, constraint-heavy tables (clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py). There is limited public evidence of ML work, large-scale distributed systems design beyond the schema, or GPU/quantization/ML training pipelines in the human-authored files.
Model Architecture & Training
How well models are designed and trained
Not evidenced in public code
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear, production-grade schema and data-contract design with many defensive DB constraints and indexes; demonstrates careful data modeling but not full pipeline/ETL code in the analyzed human-authored files.
Evidence
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: _create_books
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: _create_loans
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: _create_patrons
Experimentation & Evaluation
4/10
How results are measured and tested
Good unit-test discipline and coverage for resilience logic; tests exercise state transitions, timeouts, concurrency, and registry behavior, indicating an evaluation culture and test-first thinking.
Evidence
tests/infrastructure/test_circuit_breaker.py: comprehensive unit tests for CircuitBreaker metrics, state transitions, decorator/context manager, and concurrency/timeouts
MLOps & Deployment
How models are shipped to production
Not evidenced in public code
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to efficiency and concurrency (DB indexes, targeted check constraints, and timeout/concurrency tests) but no demonstrated GPU/batching/quantization or measured efficiency optimizations in the human-authored files.
Evidence
clean-architecture-ddd-python/migrations/versions/20260712_000001_current_schema.py: multiple indexes and GIN trigram indexes
tests/infrastructure/test_circuit_breaker.py: tests for call timeouts, non-blocking behavior, and concurrent probes
Research Depth & Innovation
1/10
Depth of research and new ideas
Limited research or novel-algorithm evidence; the circuit-breaker implementation/tests show careful design but not original research-level algorithms.
Evidence
tests/infrastructure/test_circuit_breaker.py: detailed tests implying a non-trivial circuit-breaker implementation
Technologies
MongoDB
Recommendations
- Implement and maintain backend services requiring robust PostgreSQL schema design, constraints, and indexed query performance.
- Develop reliability and resilience components such as circuit breakers, timeouts, retry policies, and thorough unit tests.
- Design and execute database migration strategies and schema evolution plans with strong validation and CI gating.
- Author integration and concurrency tests for critical infrastructure paths and operational runbooks for DB-driven services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: