Transparent, calibrated, and integrity-verified. Here is exactly how PraxiRun evaluates your cloud architecture skills.
Every component in your architecture responds to traffic like a real system. When load exceeds capacity, latency climbs, queues back up, and bottlenecks surface — exactly as they would in production. No fake numbers.
When a service goes down, PraxiRun traces every downstream dependency. Traffic reroutes, queues overflow, and cascading failures propagate in real time. You see exactly which services survive and which collapse.
Drag in AI models from leading providers and simulate real reasoning patterns — chain-of-thought, tool-use, retrieval-augmented generation, and more. Each model carries actual token cost and latency characteristics.
Components carry actual monthly costs from Azure, AWS, GCP, and IBM. As you build, PraxiRun projects your spend curve — showing how costs scale with traffic so you can optimize before committing.
Build your architecture by dragging components from a multi-cloud catalog. Connect services, configure AI agents, and set up infrastructure groups.
Run your architecture under real traffic. Watch how it handles load spikes, service failures, and cascading outages. Identify bottlenecks before they cost you.
Get scored across architecture quality, scalability, failure handling, security, governance, and cost efficiency. See exactly where your design is strong and where it’s exposed.
Compare costs across cloud providers with one click. Run what-if scenarios — 10x traffic, regional failures, budget constraints. Find the cheapest path to your requirements.
Export your validated architecture as Terraform or Pulumi. Deploy with confidence knowing it’s already been stress-tested under realistic conditions.
Continuous compliance monitoring, drift detection, and auto-rollback. Get alerted when production diverges from your certified baseline before it becomes an incident.
Every Praxirun session is evaluated across six independent dimensions. Each dimension receives a score from 0 to 100 based on the decisions you make, the components you select, how you connect them, and the reasoning you provide.
Component selection, design patterns, separation of concerns, and overall system structure.
Horizontal scaling, load balancing, caching strategies, and async processing for growth.
Redundancy, circuit breakers, dead-letter queues, graceful degradation, and DR planning.
Defense in depth, network segmentation, encryption, input sanitization, and access controls. Security scenarios map to MITRE ATT&CK techniques for industry-standard threat coverage.
Monitoring, logging, alerting, compliance, AI governance, and operational readiness.
Right-sized resources, serverless options, cost modeling at scale, and avoiding over-provisioning.
The overall score combines these dimensions through the difficulty-specific rubric, which assigns different point weights to each criterion. This means the same design may score differently at Associate vs. Principal level because the expectations change.
The Governance dimension validates your architecture against 9 industry compliance frameworks. Security scenarios additionally map to MITRE ATT&CK techniques to ensure industry-standard threat coverage.
Challenges are available at three difficulty levels. Each level has different time limits, passing thresholds, and evaluation criteria. Choose the level that matches your experience.
Entry-level cloud architecture. Demonstrate that you can select the right services, connect them logically, and address basic security and scaling needs.
Mid-level architecture design. Demonstrate resilience patterns, defense-in-depth security, horizontal scaling strategies, and operational readiness.
Senior / staff-level architecture. Demonstrate system design mastery, clear tradeoff articulation, cost modeling at scale, organizational awareness, and future-proofing.
Each difficulty level has a rubric that defines exactly how points are assigned. The rubric criteria map to the six dimensions, but the weight and expectations differ by level.
Full marks: correct service types chosen for the workload (e.g., queue for async, DB for persistence). Logical separation of concerns.
Full marks: all services connected with edges that form a valid request path. No orphan nodes. Data flows from ingress to egress.
Full marks: total monthly cost is reasonable for the problem scope. No wildly over-provisioned resources.
Full marks: authentication present, databases in private subnets, WAF or gateway in front of public endpoints.
Full marks: at least one scaling mechanism (load balancer, auto-scaler, or queue-based decoupling).
Full marks: every scenario requirement addressed. No missing capabilities.
Full marks: appropriate patterns used (event-driven for async, microservices for independent scaling). Clear separation of concerns. Well-defined boundaries.
Full marks: redundancy for critical services, circuit breakers, dead-letter queues, retry mechanisms, graceful degradation.
Full marks: defense in depth — network segmentation (VNets/subnets), encryption at rest and in transit, least-privilege IAM, input sanitization.
Full marks: horizontal scaling plan, caching layer (Redis/CDN), async processing via queues, auto-scaling policies.
Full marks: right-sized resources, serverless for variable workloads, reserved instances for steady-state, cost awareness in component selection.
Full marks: centralized logging, distributed tracing, health-check endpoints, alerting thresholds, documented DR plan.
Full marks: elegant architecture that solves the problem with minimal moving parts. Clear domain boundaries, well-chosen integration patterns, no unnecessary complexity.
Full marks: observability, security, and governance are woven into the architecture — not bolted on. Service mesh, policy-as-code, centralized secret management.
Full marks: clear reasoning captured for every major choice. Explicit trade-off analysis (cost vs latency, consistency vs availability, complexity vs resilience).
Full marks: uses novel techniques where they add real value (e.g., CQRS for read-heavy, event sourcing for audit) while relying on proven patterns for commodity concerns.
Full marks: cost model that projects growth (10x, 100x). Unit economics understood. Reserved / spot strategy. Data gravity and egress costs considered.
Full marks: team topology aligns with architecture (inverse Conway). Build-vs-buy decisions justified. Cognitive load per team considered.
Full marks: design is extensible via well-defined interfaces and contracts. New capabilities can be added without major refactoring. Avoids premature abstraction.
Raw scores are meaningless without context. We calibrate every score against a distribution of real attempts at the same scenario and difficulty level. This produces a percentile rank that tells you how your performance compares to your peers.
Percentiles are computed using a normal CDF approximation fitted to the stored distribution parameters. As more architects complete challenges, the calibration data is updated monthly to ensure accuracy.
Every session is automatically analyzed for integrity. We do not require proctoring software or webcam access. Instead, we use behavioral signals from your session to detect anomalies.
We flag sessions where complex architectures are built impossibly fast, or where nodes are added in rapid bursts that suggest automation.
Your design is compared against reference solutions using Jaccard similarity on component labels and edge topology. High similarity with known answers triggers a review.
We look for signs of genuine problem-solving: exploration, iteration (adding then removing components), pauses for thought, and natural pacing variation.
Each session receives a trust score from 0-100. Sessions above 75 are marked Verified. Between 45-75, they are flagged for review. Below 45, they are marked Suspect.
Integrity flags do not automatically invalidate your score. They add context for employers who review your verified profile. A Verified badge indicates high confidence that the work is authentic.
PraxiRun scores are designed to be actionable hiring signals. Here is how to interpret the data you see on a candidate's verified profile:
Gold (80+) candidates demonstrate expert-level architecture skills. Silver (55-79) candidates are solid mid-level practitioners. Bronze candidates have foundational knowledge but need mentoring.
A candidate in the 85th percentile at the Professional level has outperformed 85% of mid-level architects who attempted the same challenge. Compare percentiles across candidates for apples-to-apples evaluation.
Look at individual dimensions to understand strengths and gaps. A candidate might score 90 on architecture but 40 on cost efficiency — that tells you what coaching they will need.
Only consider candidates with a Verified integrity badge for high-stakes roles. Under Review candidates may have legitimate edge cases but warrant further assessment.
Always compare candidates at the same difficulty level. A Gold at Associate is not equivalent to a Gold at Principal. The Principal rubric demands system design mastery, tradeoff articulation, and organizational thinking.
Your overall score is a weighted combination of the six scoring dimensions, mapped against the difficulty-specific rubric. Each dimension is scored 0-100 independently, then mapped to the rubric's point allocation.
Gold (80+) indicates expert-level performance. Silver (55-79) indicates solid competence with room for improvement. Bronze (below 55) indicates foundational knowledge that needs development.
We compare your score against the calibration distribution for that scenario and difficulty level. Percentiles are computed using a normal CDF approximation fitted to real performance data.
Our integrity system monitors for speed anomalies, design similarity to known solutions, and behavioral patterns. Flagged sessions are marked for review and may not be accepted for verified credentials.
Every dimension breakdown includes the evaluation criteria and specific suggestions. If you believe a score is unfair, you can retry the challenge or contact support with your session ID.
Calibration distributions are recalculated monthly as new sessions are completed. Sample sizes and pass rates are always shown alongside percentile data.
Yes. Each of the 54+ adversarial scenarios across 14 domains has independent calibration data per difficulty level. Some scenarios (e.g., Prompt Injection) tend to have lower pass rates because they require specialized knowledge.