Doctoral & Post-Graduate Empirical 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

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
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?

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
Peer-Reviewed Publication: Global Journal of Business and Integral Security (GBIS)
Cloud Transformation & TCO Low-Code / No-Code Platforms Citizen Development hpaPaaS & Open Standards Vendor Lock-In 31-Metric Evaluation Framework
View Empirical Methodology, Research Questions & 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.
Read Full Research Paper DOI Citation Check Research Data Read in GBIS Journal TCO Calculator
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

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
Peer-Reviewed Publication: Empirical Dissertation Research
Microservices vs Monoliths Code Smells & Static Analysis Qualitas Corpus & Designite Infrastructure-as-Code (IaC) Technical Debt Compounding Cognitive Bias & SOA
View Empirical Methodology, Research Questions & 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.
Read Full Research Paper DOI Citation
Explore Research works
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.

Operationalizing the Blueprint for Modern Software Architecture • Grounded in 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.

Explore 789+ Patterns on designpattern.fyi
⚙️
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:
Prompt Engineering Guide AI Security
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:
OWASP Agentic AI Top 10 Securing AI Agents
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:
The Agent Loop Agent Memory Agent Skills Open Knowledge Format
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:
Fleet Engineering Agentic Resource Discovery AI Token Economy
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:
Explainable AI (XAI) Data Protection & Privacy Securing AI Agents
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:
AI Adoption Guiding Principles Healthcare Lakehouse Agentic AI Catalog
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 Elimination
The 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
Explore 789+ Patterns on designpattern.fyi Agentic AI Reference The Agent Loop OWASP Agentic AI Top 10