Doctoral, Post-Graduate & Systems Architecture Research
Future of Software Development
Investigating fundamental shifts in software architecture, cloud-native modernization, citizen development economics, code smell degradation across paradigms, and the phased operational roadmap for agentic AI systems.
Research & Publications
Research & Publications
Authored by
Dr. Amit Puri
Dr. Amit Puri
Investigating fundamental shifts in software architecture, cloud-native modernization, citizen development, and empirical code quality across monolithic, microservices, and low-code paradigms.
Perspective & Landscape:
Review research work to get a useful perspective of the tech landscape - Citizen Development
AI-Related That Matters to You
AI-Related That Matters to You
Dr. Amit Puri
Dr. Amit Puri
Doctorate in Business Administration (Data Science) · Swiss School of Business and Management, Geneva
DOI: 10.13140/RG.2.2.31414.82247
Cloud Transformation Challenges: do they favor the emergence of Low-Code and No-Code platforms?
Executive Summary & Scope
This doctoral dissertation research (Doctorate in Business Administration with specialization in Data Science 2022–2024, Swiss School of Business and Management, Geneva) investigates whether the persistent challenges organisations face during cloud transformation — cost overruns, architectural complexity, and vendor lock-in — create conditions that favor the emergence of Low-Code and No-Code (LCNC) platforms as viable solutions for enterprise digital innovation. The study delivers an executive decision framework and empirical cost-benefit model to evaluate LCNC adoption against custom cloud-native engineering.
448
Platforms Surveyed
130 LCNC + 307 adjacent integration, workflow, & no-code AI tools
31.04%
TCO Cost Savings
Demonstrated cost reduction in empirical re-platforming case model
31
Evaluation Metrics
15 Core + 7 Extended + 9 Generative Code-AI assessment criteria
10k+
Data Points Mined
AWS Lambda / S3 pipeline analyzing 2-3 years of practitioner data
Methodology Deep Dive: Research Questions, Empirical Pipeline & Key Findings
Research Framing & Core Objectives
- Problem Investigated: Evaluates how cloud transformation cost overruns, talent shortages, and architecture sprawl create conditions favorable to LCNC adoption and citizen development.
- 5 Anchoring Research Questions: (1) LCNC viability for cloud TCO reduction, (2) High-velocity modernization scenarios, (3) Key platform evaluation attributes, (4) LCNC vs traditional SaaS lock-in, and (5) Open standards (CNCF/OCI/OpenAPI) across IaaS, PaaS, FaaS, and CaaS.
- Addressing 'Silver Bullet Syndrome': Reframing LCNC as a powerful accelerator with explicit trade-offs rather than an unconditional panacea for IT complexity.
Empirical Methodology & Scale
- Two-Stage Empirical Pipeline: Automated Python ETL CRON jobs running on AWS Lambda storing data in S3, coupled with rigorous iterative manual validation.
- Broad Market Coverage: Evaluated 2,000+ candidate tools down to 448 catalogued platforms and 800+ enterprise case studies across G2, Capterra, TrustRadius, and Software Advice.
- 4-Head TCO Cost Model: Formulated structured cost heads spanning Human Capital, Operational Agility, Automation/DevOps Tooling, and Strategic CapEx.
Key Findings & Practical Artifacts
- Empirical Cost Efficiency: Re-platforming case study showed 31.04% cost reduction ($127,955 savings on $412,196 initial workload baseline).
- Sweet-Spot Scenarios: Rapid MVP/prototyping, mobile applications, business process automation, and retiring legacy technical debt (e.g. MS Access/Excel departmental tools).
- SaaS Ecosystem Lock-In: Tight integration with giants (Microsoft, Salesforce, ServiceNow) accelerates initial adoption but creates severe vendor lock-in and migration friction.
- Call for Vendor-Neutral hpaPaaS: Proposes a standardized High-Productivity Application PaaS architecture built on CNCF container standards, OpenAPI specs, and CloudEvents.
MS in Data Science · Liverpool John Moores University
DOI: 10.13140/RG.2.2.21689.65126
Study trends in code smell in microservices-based architecture, Compare with monoliths
Executive Summary & Scope
This empirical MS in Data Science dissertation research (Liverpool John Moores University) treats the monolith-to-microservices migration as a controlled natural experiment to determine what actually happens to code smells when systems are re-platformed into microservices, testing whether 'modern' architecture inherently guarantees 'cleaner' software.
754
Monolith Versions
112 systems in Qualitas Corpus analyzed longitudinally across release cycles
80%
Coupling Smell Drop
Sharp collapse in Deficient Encapsulation, Cyclic Dependencies, & Broken Hierarchies
18 Repos
Microservices Dataset
Curated Java & C# microservices including Dockerfiles & YAML manifests
16x-17x
Compounding Debt
Longitudinal aging demonstrated non-linear smell amplification vs LOC growth
Methodology Deep Dive: Research Questions, Empirical Pipeline & Key Findings
Research Questions & Scope
- Core Question: Does software quality degrade during cloud migration, and which specific architectural metrics shift when migrating from monoliths to microservices?
- Investigating LCNC Drivers: Examines whether the frictional overhead of microservices rewrites nudges enterprises toward No-Code/Low-Code platforms (Power Platform, AppSheet).
- Closing the Comparative Gap: First direct, metric-calibrated side-by-side comparison using a unified static analysis pipeline across both paradigms.
Datasets & Analysis Pipeline
- Qualitas Corpus Baseline: 12 benchmark Java monoliths (Hibernate, Spring, Tomcat, Derby, Lucene, ANTLR, Ant) spanning earliest to latest versions.
- Curated Microservices Corpus: 18 open-source repositories in Java and C# evaluated alongside their Infrastructure-as-Code (IaC) Dockerfiles and YAML manifests.
- Multi-Level Metric Tooling: Automated extraction using Designite (Cyclomatic Complexity >8, Class LOC >1000, LCOM >0.8, Fan-in/out >20), cloc/sloc, and custom R statistical scripts (
process-cs-data.R,analyze-data-func.R).
Key Quantitative Findings & Insights
- Structural Smells Collapse in Microservices: Deficient Encapsulation plummeted (187 → 37), Cyclic Dependencies dropped (146 → 31), Broken Hierarchy fell (168 → 39), and Complex Methods shrank (80 → 11) as smaller service boundaries naturally curtail God-class sprawl.
- Discipline Smells Persist or Worsen: Unutilised Abstraction surged from 191 in monoliths to 416 in microservices, and Long Statements climbed from 318 to 385 — proving architectural decomposition cannot fix coding discipline.
- Architecture-Neutral Smells: Magic Number occurred at virtually identical frequencies (267 vs 226) across both paradigms.
- Compounding Debt with Age: Apache Ant longitudinal tracking (v1.1 → v1.8.4) proved technical debt is non-linear: a 6× LOC growth caused a 16× jump in encapsulation smells and a 17× jump in parameter lists.
- Practitioner Bottom Line: Never assume a microservices rewrite buys cleaner code. Configure CI linters specifically for unused abstractions, statement length, and IaC YAML hygiene.
Technical Research Paper · 18 Retrieval Strategies · Open Benchmark
Research Paper
Hybrid Retrieval Strategies for Retrieval-Augmented Generation over Scientific PDF Corpora: An Empirical Comparison
Executive Summary & Scope
This empirical systems research evaluates eighteen retrieval strategies (fifteen core architectures plus three factorial ablation configurations) over an expanded corpus of scientific PDF documents (44 arXiv-style papers, 1,709 pages, 9,558 structured chunks) across 22 curated benchmark queries (16 single-hop + 6 multi-hop reasoning) with explicit chunk-level ground truth and entity/relation annotations. We measure MRR, Recall@{1,3,5}, NDCG@5, Entity Coverage (EntCov), and Relation Coverage (RelCov) across all strategies, establishing empirical findings on sparse lexical dominance for domain jargon, rank-space fusion (RRF), cross-encoder joint cross-attention for multi-hop reasoning, knowledge-graph structural traversal, and lossless HNSW ANN vector search.
18
Retrieval Strategies
15 core architectures + 3 factorial ablation configurations evaluated
9,558
Structured Chunks
44 arXiv computer science & AI papers comprising 1,709 pages
0.833
Multi-Hop Recall@5
Cross-encoder joint attention ceiling on complex reasoning queries
0.902
Entity Coverage
NetworkX 1-hop knowledge-graph augmentation with IDF weighting
Methodology Deep Dive: Research Questions, Empirical Pipeline & Key Findings
Empirical Research Framing & Core RQ
- Problem Investigated: Eliminates guesswork in RAG design by empirically comparing sparse (BM25, TF-IDF), dense bi-encoders (MiniLM, SPECTER2), linear score blends, rank fusion (RRF), cross-encoder rerankers, knowledge graph augmentation, and HNSW ANN vector search on technical literature.
- Domain Jargon Challenge: Demonstrates that off-the-shelf dense bi-encoders diffuse coined technical vocabulary (*'StarShell'*, *'POMDP'*, *'AgentRunner'*), where pure BM25 achieves 0.551 MRR vs. 0.318 for MiniLM and 0.278 for SPECTER2.
- Rank-Space vs. Score Fusion: Linear hybrid combinations degrade monotonically as dense weighting increases (0.503 → 0.471 MRR), whereas Reciprocal Rank Fusion ($k=60$) avoids score-scale distortion (0.514 MRR, 0.318 Recall@1).
Multi-Hop Division of Labor & Graph-RAG
- Multi-Hop Reasoning Ceiling: While cross-encoders underperform first-stage RRF on single-hop lexical queries (0.481 vs 0.514 MRR), they decisively lead on multi-hop reasoning queries (**0.408 MRR, 0.513 NDCG@5, 0.833 Recall@5**), confirming the necessity of deep query-passage cross-attention.
- Factorial Graph-RAG Ablation: Isolates the standalone and interaction effects of 1-hop NetworkX traversal, sliding-window deduplication, and MMR (λ=0.7). Knowledge-graph fusion achieves benchmark-leading structural coverage (**0.902 EntCov, 0.727 RelCov**) and elevates Recall@1 to 0.364.
- Lossless Vector ANN: Qdrant HNSW vector search reproduces exact-search dense metrics identically (0.318 MRR, 0.335 NDCG@5) at 9,558 chunks while establishing persistent, sub-millisecond production execution.
Production Architecture & Confidence Calibration
- Decoupled 3-Pipeline Architecture: Strict separation of Ingestion (multi-backend PDF parsing, SHA-256 caching, Parquet/Qdrant storage), Retrieval (18 dispatchable strategies), and Generation (bracketed provenance headers).
- Calibrated Confidence (C3): Formalizes per-claim confidence (HIGH, MEDIUM, LOW) derived directly from rank position, fusion scores, and lexical overlap without incurring auxiliary LLM latency or cost.
- Multi-Provider Frontier Routing: Validated grounded synthesis across OpenAI (gpt-5.5), Anthropic (claude-sonnet-5), and Google Gemini (gemini-3.8-flash) with zero hallucinated claims.
Architecture Blueprint & Phased Execution
Roadmap: Operationalizing the Blueprint for Modern Software Architecture
A practical adoption roadmap translating empirical research on microservices, code smells, and cloud/LCNC transformation into a 6-phase operational plan for Agentic AI architecture — grounded in 789+ patterns at designpattern.fyi.
Prelude
The Paradigm Shift: From Syntax to Intent
Software development is shifting from writing syntax to articulating intent. English — or more broadly, natural language — is becoming the new programming interface: you describe the outcome, inject context, and let an agent loop iterate toward it. But precision still matters; a well-structured prompt is really just a spec in disguise, and vague intent still produces vague software.
The harder question isn't language, it's infrastructure. Agent loops need guardrails — every autonomous step is a new surface to secure, govern, and observe. So the future probably isn't "no infra," but invisible infra: cloud and SaaS platforms doing the scaling, permissioning, and auditing so the agent (and the human) can move fast without moving recklessly. LLM-first, search-first, and security-first aren't separate priorities — they converge into one requirement: trustworthy autonomy.
And maybe CI/CD doesn't disappear either — it compresses. "Build on the fly" doesn't replace testing and review; it collapses the loop from days to seconds, with verification baked into the agent's own iteration rather than bolted on after.
Adoption Methodology • How to Read This Roadmap
Diagnostic Pass First
Like the 2021 code-smell study, start with static analysis before structural changes — distinguishing true architectural flaws from coding discipline issues.
Recurring TCO Checkpoints
Like the 2024 DBA thesis TCO model, re-evaluate total costs at each phase — accounting for token consumption, agent fleet tooling, and governance overhead.
designpattern.fyi Traceability
Every phase maps directly to established patterns catalogued at designpattern.fyi, ensuring execution remains concrete and reproducible.
Overlapping Phased Execution
Phases are sequential in emphasis but overlap across squads — one team can run Phase 2 reference architectures while another completes Phase 0 baselines.
The Complete Agentic AI Reference
Every aspect of designing, securing, and governing AI agents — balancing autonomous execution with human oversight, guardrails, and responsible control at every layer.
⚙️
Core Architecture
Core patterns for agents that reason, act, and defer to humans when it matters
🔄
The Agent Loop
Think-Act-Observe cycle — how LLMs become engineers, with configurable checkpoints for human review and approval.
🧠
Agent Memory
Multi-tiered persistent context — working, episodic, semantic, and procedural memory stores.
🎯
Agent Skills
Portable, version-controlled knowledge packages for specialized agent capabilities.
📋
Open Knowledge Format (OKF)
Google's minimal, interoperable format for representing organizational knowledge in agents.
🚀
Orchestration & Operations
Scale and operate agents with human supervision, cost controls, and operational guardrails
🛸
Fleet Engineering
Orchestrate large agent deployments with lifecycle policies, human escalation paths, and SRE-grade observability.
🌐
Agentic Resource Discovery (ARD)
Open federated spec for publishing, discovering, and verifying AI capabilities — DNS for agents.
💰
AI Token Economy
Token pricing, cost optimization, caching strategies, and enterprise AI economics at scale.
✏️
Prompt Engineering Guide
Interactive workspace for professional prompt structures — chain-of-thought, few-shot, and more.
🛡️
Security & Governance
Defend, audit, and govern agents — keeping humans in control of critical decisions
🔐
Securing AI Agents
Google DeepMind's framework — AI Control Roadmap, GRAM, and three layers of agent security.
⚠️
OWASP Agentic AI Top 10
The 10 critical risks for agentic systems — why human oversight and control boundaries are non-negotiable.
🔴
AI Security Threat Taxonomy
Threat taxonomy — data poisoning, adversarial attacks, supply chain, and AI-driven exploits.
🔍
Explainable AI (XAI)
Thinking traces and trajectory diagnostics that make agent decisions auditable and explainable to human reviewers.
🎭
Data Protection & Privacy
Masking, tokenization, PII redaction, and synthetic data with pre/post LLM hooks for agents.
🏢
Strategy & Domain Applications
Adopting agentic AI responsibly — from supervised pilots to measured autonomy at scale
🎯
AI Adoption Guiding Principles
Staged adoption framework from traditional ML to Agentic AI — with HITL guardrails across healthcare, airlines, and insurance.
🏥
Scaling Agentic AI: Healthcare Lakehouse
5-tier medallion architecture for agentic AI in healthcare — dynamic orchestration between autonomy and clinical HITL.
🛠️
AI Agent Skills Builder
Interactive tool to design custom AI agent skills following best practices from Claude, Gemini, and GPT.
🌟
Agentic AI Full Pattern Catalog
Full catalog of agentic AI patterns, frameworks, and reference architectures.
The 6-Phase Operational Execution Plan
Phased progression from static diagnostics to enterprise-scale agentic fleet governance and strategic TCO optimization.
Phase 0
Diagnostic Pass
Baseline & Diagnostic
Goal:
Know what you are actually starting from before picking a fix or embarking on refactoring.
designpattern.fyi Patterns:
Key Actions & Architectural Focus:
- Static analysis calibration: Run static analyzers weighting results per the 2021 study — specifically tracking Unutilized Abstraction and Long Statement, which persist across monoliths and microservices alike.
- LCNC & tool sprawl inventory: Catalog every citizen-developer tool and shadow IT workflow in use, mapping the SaaS ecosystem it is tied to as input for lock-in evaluation.
- Flag God Prompt patterns: Identify any single monolithic prompt or agent handling multiple unsegmented responsibilities with zero HITL gates and no output schema validation.
Phase Deliverable:
Baseline scorecard covering code-smell density, LCNC tool sprawl, and agentic-AI exposure, serving as the benchmark for all future phases.
Phase 1
Runtime Safety
Guardrails Before Growth
Goal:
Put non-deterministic software primitives in place before scaling agent volume or autonomy.
designpattern.fyi Patterns:
Key Actions & Architectural Focus:
- Semantic routing layer: Deploy an embedding-based or fine-tuned classifier that routes simple queries to fast models and reserves deep reasoning for complex tasks — drawing service boundaries early.
- Validator-corrector loops: Wrap every model output feeding downstream systems in schema validation, structured error capture, and targeted re-prompting — mandatory for production data.
- OWASP Agentic AI Top 10 checklist: Audit all capabilities against goal hijack, tool misuse, privilege abuse, supply chain vulnerabilities, memory poisoning, and cascading failures.
Phase Deliverable:
Routing + validation layer live in front of at least one production agentic workflow, plus a completed OWASP Agentic AI Top 10 checklist.
Phase 2
Scaffolding Standard
Reference Architecture Adoption
Goal:
Standardize agent scaffolding so capability does not outpace maintainability as codebases scale.
designpattern.fyi Patterns:
Key Actions & Architectural Focus:
- The Agent Loop as default: Standardize on Perceive → Plan → Act → Observe → Iterate, embedding an explicit named Human-in-the-Loop (HITL) checkpoint from day one.
- Tiered Agent Memory: Separate working memory (context window), episodic memory (session logs), semantic memory (domain facts), and procedural memory (SOPs).
- Agent Skills encapsulation: Package reusable tool bundles with SKILL.md and progressive disclosure so discovery costs remain near-zero at boot.
- Open Knowledge Format (OKF): Use standardized markdown concepts with YAML frontmatter for shared institutional knowledge across teams.
Phase Deliverable:
One fully documented reference implementation of the Agent Loop + Memory + Skills pattern that all squads copy and adapt.
Phase 3
Fleet Engineering
Orchestration at Scale
Goal:
Apply Infrastructure-as-Code and control-plane rigor to a multi-agent fleet.
designpattern.fyi Patterns:
Key Actions & Architectural Focus:
- Fleet Engineering control plane: Centralize task decomposition, agent selection, versioned prompt deployments with blue/green canaries, and execution lifecycle management.
- Agentic Resource Discovery (ARD): Catalog-and-registry model with domain-anchored URNs and cryptographic trust manifests across team boundaries.
- AI Token Economy governance: Enforce real-time cost telemetry, prompt caching, token quotas, and automated cost attribution per team and workload.
Phase Deliverable:
Fleet observability dashboard tracking cost, latency, and success rates per agent/workflow, with instant version rollback capability.
Phase 4
Enterprise Trust
Security, Governance & Human Oversight
Goal:
Enforce enterprise governance and verifiable auditability on non-deterministic systems.
designpattern.fyi Patterns:
Key Actions & Architectural Focus:
- HITL gateways at critical boundaries: Freeze execution on financial transactions, production data mutations, credential changes, and external communications until explicit sign-off.
- Thinking-trace auditability: Capture structured reasoning chains and tool invocations in immutable logs so reviewers can audit *why* a decision was made.
- Data protection hooks: Enforce PII redaction, tokenization, masking, and synthetic data generation across pre-LLM and post-LLM boundaries.
- OWASP AIVSS scoring: Prioritize security remediation by exploitability and blast radius rather than recency of discovery.
Phase Deliverable:
Governance register mapping every production agent to its HITL checkpoints, audit trail location, and AIVSS vulnerability score.
Phase 5
Strategic TCO
Strategic Scale-Out & Platform Decisions
Goal:
Revisit Build vs. Buy vs. Agent-Native decisions using an extended TCO methodology.
designpattern.fyi Patterns:
Key Actions & Architectural Focus:
- Staged maturity progression: Advance domains progressively: Traditional ML (predictive) → Generative AI (creative) → Agentic AI (autonomous action).
- 3-Step Extended TCO modeling: Re-run the DBA thesis cost model extended for token consumption, agent fleet licenses, and governance overhead.
- Vendor-neutral orchestration: Proactively prevent ecosystem lock-in by favoring open standards (CNCF containers, OpenAPI, CloudEvents) — the agentic hpaPaaS principle.
Phase Deliverable:
Comprehensive TCO comparison across custom build, LCNC, and agent-native alternatives for each core enterprise workload, reviewed annually.
Governance Cadence & Metrics
Continuous Checkpoints| Phase | Primary Metric | Target Signal | Tooling / Source of Truth |
|---|---|---|---|
| Phase 0 — Baseline | Unused-abstraction & long-statement smell density | Flat or decreasing post-release | Static analysis (Designite / SonarQube) |
| Phase 1 — Guardrails | % of agent outputs passing validator on first pass | Rising continuously over time | Validator-corrector execution logs |
| Phase 2 — Reference Architecture | % of squads reusing standardized Agent Skills | Increasing skill reuse rate across squads | Internal Agent Skills registry |
| Phase 3 — Orchestration | Cost per task completion & agent rollback frequency | Cost stabilizing; rollback frequency < 1% | Fleet observability dashboard & APM |
| Phase 4 — Governance | % of irreversible actions with verified HITL log | 100% compliance mandatory | Governance register & audit trail |
| Phase 5 — Strategy | TCO delta across Custom / LCNC / Agent-Native | Refreshed & validated within 12 months | 3-Step TCO comparison model |
Anti-Patterns to Retire Along the Way
Architecture Debt EliminationThe God Prompt
One massive prompt or agent attempting every responsibility without decomposition — the agentic equivalent of the God Class.
Unbounded Autonomy
Granting autonomous execution privileges for irreversible actions with no HITL gateway — the direct trigger for cascading failures.
Shadow Agent Sprawl
Unregistered agents and ad-hoc LCNC workflows operating outside central discovery, repeating the shadow IT governance failure.
Cost Blindness
Scaling agent deployment before token-economy controls, caching, and budget attribution are active — leading to runaway token bills.
Static-Analysis-Only Quality Control
Relying strictly on post-hoc code scanners or manual output review without proactive runtime routing and schema validators.
Roles & Ownership (Lightweight RACI Matrix)
Accountability Matrix| Workstream | Accountable | Responsible | Consulted | Informed |
|---|---|---|---|---|
| Baseline Diagnostic (Phase 0) | Engineering Leadership | Platform & Architecture Squad | Security & Data Teams | All Engineering |
| Guardrails & Primitives (Phase 1) | Platform & Architecture Squad | Agent Platform Engineers | Application Security | Product Teams |
| Reference Architecture (Phase 2) | Platform & Architecture Squad | Agent Platform Engineers | Product Teams | All Engineering |
| Fleet Orchestration (Phase 3) | Platform & SRE Lead | Platform & SRE Engineers | FinOps / Finance | Engineering Leadership |
| Security & Governance (Phase 4) | CISO / Risk Owner | Security Engineers | Legal & Compliance | Executive Sponsor |
| Strategy & Scale-Out (Phase 5) | Executive Sponsor | Architecture Team & FinOps | Domain & Product Owners | Steering Committee |
Source Traceability • Where Each Phase Draws From
Empirical Research Grounding
Phase 0 — Baseline & Diagnostic
2021 Code-Smell Study (LJMU) — Comparative static analysis & debt tracking
Phase 1 — Guardrails Before Growth
Architectural Primitives for Non-Deterministic Software — Semantic Routing & Validator Loops
Phase 2 — Reference Architecture
The Complete Agentic AI Reference — Agent Loop, Memory, Skills & OKF
Phase 3 — Orchestration at Scale
Fleet Engineering, Agentic Resource Discovery & Token Economy
Phase 4 — Security & Governance
OWASP Agentic AI Top 10, AIVSS Scoring, XAI & HITL Gateways
Phase 5 — Strategic Scale-Out
2024 DBA Thesis (SSBM) — 3-Step TCO Methodology & hpaPaaS Vendor Neutrality