About
I am an Application Architect who focuses on bridging the gap between complex enterprise…
Activity
910 followers
-
Venkatesh Duvvuri shared thisWhat if you could run sub-50ms "System One" decision models locally on your own hardware for $0? While TypeSafe AI made waves with Jev, the open-source community delivered an open-weight alternative: Laya, developed by Nandakishor M and the team at Convai Innovations. Released under the Apache 2.0 license, Laya brings non-autoregressive, zero-hallucination decision loops directly to self-hosted runtimes. Here is why Laya is a game-changer for edge and backend engineering: ⚡ Blazing Fast Local Latency: Runs in ~33ms on local GPUs and ~3.7ms via CoreML on Apple Silicon (via laya.cpp, WASM, or MLX). 🔒 Privacy-First & Zero Token Tax: No sensitive data sent to third-party cloud APIs, and $0 operational cost. It’s fully self-hosted. 🎯 Structured Decision Primitives: Rather than generating text, Laya evaluates unstructured inputs in a single forward pass to output calibrated primitives: • choice: Multi-class routing • score: Ordinal ranking • noul: Boolean probability P(true) 🤖 Honest Under Ambiguity: When faced with unclear or ambiguous inputs, Laya doesn't hallucinate an overconfident guess. It emits calibrated, middle-of-the-road probabilities (e.g., 51% / 49%), allowing your code to safely route edge cases to human review. 💡 The Big Takeaway: System One models are shifting from a cloud API trend to an open-source standard. You don't need a massive chat LLM to route an event or trigger a backend workflow. Are you exploring small, task-specific models for local runtime decisions? #OpenSource #AI #MachineLearning #SystemOne #LocalAI #SoftwareEngineering #EdgeAI #techievenki
-
Venkatesh Duvvuri shared thisWhy are we using $10/MTok chat models as glorified if-else statements? Former OpenAI researcher Diogo Almeida spent four years asking a fundamental question: If LLMs are superhuman at chat, where is all the enterprise software automation? The bottleneck isn't intelligence it’s the string generation tax. TypeSafe AI recently launched Jev, a "System One" frontier model engineered specifically for software runtime environments rather than conversational text. Here is how it shifts the stack: ⚡ Sub-100ms Parallel Sampling: Evaluates unstructured inputs in a single forward pass instead of predicting strings token-by-token. 🔒 Zero Structural Hallucinations: Constrained schemas natively eliminate type errors and broken JSON parsers. 🎯 Calibrated Probabilities (RLCD): Outputs epistemically honest confidence scores alongside every typed decision. 🤖 Real-Time Robotics & Guardrails: Gives physical controllers and backend APIs deterministic, low-latency feedback. 💡 The Analogy: Traditional LLMs act like a thoughtful essayist typing out a paragraph when you ask for a sentiment score. Jev acts like a instant touchscreen cashier: it emits {"sentiment": "positive", "confidence": 0.98} in 80 milliseconds. ⚠️ The Trade-offs: When NOT to use System One Models Giving up autoregressive string generation comes with clear boundary lines: 1️⃣ No Text Generation: Jev cannot write emails, draft code, or chat with users. It is strictly a decision engine, not a conversational assistant. 2️⃣ No Chain-of-Thought Visibility: Because evaluation happens in a single parallel pass, you lose readable, step-by-step reasoning traces. 3️⃣ Rigid Output Schemas: Decisions must fit pre-defined categorical schemas. It cannot improvise or hand-wave open-ended scenarios. System One models aren't replacing LLMs—they are replacing the fragile, slow string loops we built inside backend code. Are we renting expensive System 2 models for tasks that only need fast, rigid System 1 judgment? Ref: https://lnkd.in/eA4Af8QK #ArtificialIntelligence #SystemOne #MachineLearning #SoftwareArchitecture #Robotics #TypeSafeAI #techyvenki
-
Venkatesh Duvvuri shared thisFirst, Cursor built Origin a code editor re-imagined from the ground up for AI agents rather than human developers. Now comes Cloudflare Kitesurf a web browser built purely as an engine for AI. For years, running autonomous AI agents that browse the web meant shoehorning agentic workflows into general-purpose Chrome instances. We were paying heavy compute overhead for tabs, UI extensions, bookmarks, and local storage that an LLM agent simply doesn't need. The paradigm is shifting from Human Browsers to AI-Agent Engines: 🔹 Human Browsers (Chrome, Safari): Heavy binary apps designed for visual UI rendering, long-lived sessions, and human interaction. They pull 500MB–1GB+ RAM per tab. 🔹 AI-Agent Browsers (Cloudflare Kitesurf): Zero-Chromium, stateless execution layers built with Rust and WebAssembly that run directly inside V8 serverless isolates on edge networks. Key Kitesurf Highlights: ⚡ 3x–7x lower CPU/Memory footprint compared to standard Chromium. ⚡ Stateless Execution: Spins up, extracts DOM/screenshots, and tears down in milliseconds. ⚡ Agent-Native Protocols: Direct integration with Model Context Protocol (MCP) and Chrome DevTools Protocol (CDP). The Ecosystem Split: We are seeing two clear tiers of AI browsers emerge: * Agent Infrastructure (Backend): Headless execution layers like Kitesurf, Browserbase, and Steel built for LLM scraping, DOM parsing, and automated tasks. * Consumer-Facing AI Browsers (UI): Desktop browsers with embedded agents like Perplexity Comet, ChatGPT Atlas, and Arc/Neon. Just like IDEs evolved to agent-native environments, web infrastructure is now shifting to agent-native runtimes. The developer stack isn't just being upgraded for AI it's being completely rebuilt for it. Are you moving your agent automation workloads to lightweight edge runtimes yet? #Cloudflare #Kitesurf #AgenticAI #DevOps #CloudComputing #SoftwareEngineering #MCP #Serverless #techievenki
-
Venkatesh Duvvuri shared thisThe AI frontend tooling ecosystem has converged on a make-or-break question: Can these generators actually respect enterprise design systems, or do they just hallucinate generic markup? Here is how the top tools handle custom components, design tokens, and production UI frameworks: 1. Enterprise Design System & Token Integration v0 (Vercel) — Custom Registries: Adopts the open shadcn/ui registry spec. Point v0 to a private registry exposing your @company/ui components and CSS variables. It imports your exact primitives directly, enforcing brand tokens out of the box. Figma Make — Make Kits: Combines published Figma Team Libraries (variables, typography, auto-layouts) with internal npm packages (@scope/design-system) and custom guidelines.md rules. Generates interactive prototypes using real components, not approximations. Lovable / Bolt — Starter Templates: Centralized "Design System Projects" feed downstream apps. Custom tokens are managed via global CSS variables and extended in tailwind.config.ts, backed by pre-bundled org templates. Replit Agent — Workspace Rules: Operates in a full-stack Linux sandbox. Governed through repo templates containing your UI kit and workspace rules (.replit instructions) mandating consumption of internal packages from private npm/Artifactory registries. Claude (Projects / Artifacts) — Knowledge Directives: Ingests design token definitions, SVG icon sets, and Tailwind configs inside Project Knowledge. Claude’s spatial reasoning and layout adherence enforce these guardrails across chat iterations. 2. Output Languages & Supported Runtimes v0: TS/TSX & JSX | React / Next.js | Tailwind CSS, Radix UI, CSS Variables Figma Make: TS, JS, CSS | React + Vite | Figma Variables, Tailwind, Linked npm packages Lovable / Bolt: TS/TSX | React + Vite SPAs | Tailwind CSS, shadcn/ui, Radix UI Replit Agent: Polyglot (TS, JS, Python, Go) | React, Vue, Svelte, Full-Stack | Tailwind, MUI, Bootstrap, Raw CSS Claude: TSX, JS, HTML/SVG | Standalone React, Static Canvas | Tailwind CDN, Scoped CSS The Playbook: Where to Deploy Each Production Codebases: v0 delivers clean, modular React/Tailwind code ready for enterprise PRs. Design System Fidelity: Figma Make anchors code directly to Figma components and design tokens. Full-Stack Execution: Replit or Lovable provide instant backend wiring, databases, and live deployments. Ideation & Architecture: Claude excels at early visual prototyping, layout iteration, and system mapping. The takeaway: Design-first teams gain the most leverage from Figma Make Kits. Code-first engineering orgs should deploy private shadcn-compatible registries to v0, shifting UI governance left on day one. What strategy is your team using to govern AI UI generation centralized component registries, repo rules, or custom kits? #GenerativeAI #DesignSystems #FrontendEngineering #React #TypeScript #Figma #WebDevelopment
-
Venkatesh Duvvuri shared thisMost guides treat concepts like chunking, hybrid search, KV caches, circuit breakers, and prompt injection as isolated flashcards. That never sat right with me. In production, these aren’t disconnected vocabulary words; they are the exact path a single request travels from the moment a user hits "enter" to the moment an answer streams back. To bridge that gap, I built an interactive companion to my "LLM from scratch" series that traces a single real-world question through all twenty steps. A customer types four words: "Why is it late?" No order number. No tracking ID. The word "it" is doing heavy lifting. Delivering an accurate response in under three seconds requires twenty sequential operations to execute seamlessly: - Months-old chunking strategies dividing the knowledge base - Query expansion to turn vague intent into searchable parameters - Hybrid search running sparse and dense retrieval in parallel, followed by reranking - Dynamic routing to the right model tier - KV cache management during generation - Sandboxed tool calls to the courier’s API - Guardrails to prevent prompt injections hidden in editable support docs - Audit tracing to prove why the system gave that specific answer I built this around two core principles: - Plain-language intuition before formal theory. If a circuit breaker can’t be explained simply as "if the courier's API is dead, stop hammering it every ten seconds," the technical definition isn't doing its job. - Interactive instrumentation over static diagrams. Instead of reading architecture charts, you test live widgets. Feed tracking numbers into a live BM25 scorer, trigger and recover a crashed checkpoint workflow mid-execution, trip a live circuit breaker, and run a real prompt injection attack across secure and vulnerable boundaries to watch how context poisoning happens. The biggest takeaway after building all twenty? Only about half of the stack involves AI models. The rest checkpointing, backpressure, scoped credentials, distributed tracing is classic systems engineering wrapped around an expensive, non-deterministic engine. That unglamorous half is usually what determines whether an AI demo survives contact with real users. Link in the comments. Built as a direct companion to techievenki.ai/howllmworks. Curious: which of these layers do you see teams neglect most when moving from proof-of-concept to production? #AIEngineering #LLM #SystemDesign #RAG #SoftwareEngineering #techievenki
-
Venkatesh Duvvuri shared thisIf you ask an engineer "How does an LLM work?", the standard answer is: "It predicts the next token." While true, that completely skips the real engineering stack. Under the hood, building, training, and serving modern models comes down to 3 macro phases and 7 core modules: Phase 1 — Foundations 01. Tokens & Parameters — What a model actually reads, and what "27B" or "4-bit" translates to in real VRAM / gigabytes. 02. The Transformer Block — Embeddings, multi-head attention, and the fundamental building block that repeats across the model. Phase 2 — Training 03. Pre-Training — Trillions of tokens, one objective (predict the next one), and how the raw base model is born. 04. Post-Training (SFT / RLHF) — Turning a raw token predictor into a capable assistant (and why each new release reruns this pipeline). Phase 3 — Efficiency & Scale 05. Compression — Quantization, knowledge distillation, and MoE (Mixture of Experts) to make models smaller, faster, and cheaper. 06. Architecture Patterns — Full vs. linear attention, hybrid stacks, and why models like Qwen and Kimi look architecturally distinct. 07. Serving & Inference — The KV cache, context scaling, and why 4-bit quantization counterintuitively runs the fastest in production. --- Static blog diagrams often difficult to explain how weights, KV cache memory, and attention mechanisms operate dynamically. I tried to come up with an interactive 7-part visual guide where you can explore and step through every module live in your browser: 🔗 Link to the interactive visualizer is in the first comment below! 👇 Which module (01 to 07) do you feel is the biggest hurdle for teams deploying LLMs in production today? #GenerativeAI #MachineLearning #LLMOps #AIArchitecture #DeepLearning #SystemDesign #SoftwareEngineering
-
Venkatesh Duvvuri shared this🚀 Stop training AI inside its own hallucinations. Standard model-based Reinforcement Learning (RL) has a major flaw: when you train a policy on imagined world-model rollouts, small prediction errors compound exponentially. The agent inherits every single mistake the imagination makes. A new paper from Stanford & Peking University ("Q-Learning with World Models" by Perry Dong, Yueru Jia, Chelsea Finn, & Dorsa Sadigh) solves this with a dead-simple, brilliant insight: 👉 "Never learn there. Only think there." Here is how QWM changes the paradigm: * 🧠 Real-World Grounding: The policy and Q-function are trained strictly on real, online execution data. No hallucinated trajectories ever touch the model's weight updates. * 🔮 Test-Time Imagination: The world model is used exclusively during inference to run tree-based searches over imagined trajectories. * 🎯 Grounded Evaluation: Imagined future states are scored using the real-grounded Q-critic, letting the robot pick high-value actions without inheriting model bias. 💡 Real-World Example: Imagine a robot arm executing a can pick-and-place task. Before moving, QWM generates candidate actions (approach from left, move straight, close gripper early). The world model imagines the immediate future frames for each candidate, but instead of letting the world model guess the overall task success, QWM uses its real-world trained Q-critic to evaluate the imagined end-states. It immediately prunes bad paths (like overshooting the can) and executes only the optimal trajectory. The Result: Massive gains in sample efficiency and task completion on complex visual manipulation benchmarks like Robomimic and LIBERO (can pick-and-place, precision nut insertion, and tool manipulation). Decoupling imagination for decision-making from imagination for training might just be the unlock for scaling foundation world models in physical AI and robotics. What are your thoughts on using world models for inference-time search versus end-to-end training? #Robotics #ReinforcementLearning #ArtificialIntelligence #MachineLearning #DeepLearning #TechieVenkiAI #StanfordAI #WorldModels
-
Venkatesh Duvvuri shared this𝐈𝐬 𝐆𝐢𝐭𝐇𝐮𝐛 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐫𝐞𝐚𝐝𝐲 𝐟𝐨𝐫 𝐭𝐡𝐞 𝐀𝐠𝐞𝐧𝐭𝐢𝐜 𝐄𝐫𝐚? 🤖💻 When developers started shipping thousands of AI-generated lines daily, a major bottleneck emerged: our developer infrastructure was built for human speeds. - PR queues, linear review flows, and constant tab-switching between GitHub and the IDE were designed for human developers. When autonomous cloud agents generate code, test changes, and attempt to resolve feedback concurrently, traditional platforms hit review blockages and operational fatigue. Enter Cursor Origin a Git-compatible code-hosting platform built ground-up inside the editor to bring code, PRs, and AI agents onto the exact same layer. 🔹 Human-Centric vs. Agent-Native: GitHub treats AI as an external contributor calling into the forge. Origin embeds background cloud agents natively into the code-hosting layer so they can clone, branch, commit, push, and open PRs autonomously. 🔹 Linear PRs vs. Stacked PRs: Leveraging tech from their Graphite acquisition, Origin supports stacked PR engineering so agents and teams can chain small, dependent changes without blocking workflow threads. 🔹 In-Editor Execution: Review diffs, trigger automated agent fixes on inline comments, and browse code without opening a single browser tab. 🔹 Coexistence Strategy: Origin doesn't demand an immediate migration—it supports two-way bidirectional sync with GitHub repos, mirroring code and comment timelines while keeping GitHub as the source of truth. 📊 GitHub vs. Cursor Origin: Feature & Ecosystem Matrix - How does Origin handle native GitHub features like Actions, Pages, Copilot, and Code Reviews? - ⚙️ CI/CD Automation (GitHub Actions vs. External Runners) - GitHub: Runs native GitHub Actions for build matrices, linting, and automated releases. - Origin: Has no native CI engine like Actions. Native Origin repos delegate builds to third-party integrations like Depot, Buildkite, and Vercel. (If using Origin in mirror mode, your GitHub Actions still execute normally on GitHub). - 🌐 Static Site Hosting (GitHub Pages vs. Deployments) - GitHub: Native, free static site hosting via GitHub Pages attached directly to branches. - Origin: Not supported natively. Offloads web deployment entirely to hosting platforms like Vercel or Netlify. - 🤖 AI Assistant & Code Reviews (GitHub Copilot vs. Cursor Cloud Agents) 💳 Pricing & Accessibility - GitHub: Freemium & Open Source Standard. Unlimited public/private repos, free Actions minutes, and open community discovery. - Origin: Paid-Only & Private Repos (Early Beta). Bundled into paid Cursor plans (Pro/Teams/Enterprise). Currently lacks public repo support, making it unsuitable for open-source hosting today. - Is Origin a "GitHub Killer" today? No currently GitHub's enterprise governance, security marketplace, and public open-source moat remain unmatched. #SoftwareEngineering #AIAgents #DeveloperExperience #Cursor #GitHub #DevOps #SystemArchitecture #techievenki
-
Venkatesh Duvvuri liked thisWhy are we using $10/MTok chat models as glorified if-else statements? Former OpenAI researcher Diogo Almeida spent four years asking a fundamental question: If LLMs are superhuman at chat, where is all the enterprise software automation? The bottleneck isn't intelligence it’s the string generation tax. TypeSafe AI recently launched Jev, a "System One" frontier model engineered specifically for software runtime environments rather than conversational text. Here is how it shifts the stack: ⚡ Sub-100ms Parallel Sampling: Evaluates unstructured inputs in a single forward pass instead of predicting strings token-by-token. 🔒 Zero Structural Hallucinations: Constrained schemas natively eliminate type errors and broken JSON parsers. 🎯 Calibrated Probabilities (RLCD): Outputs epistemically honest confidence scores alongside every typed decision. 🤖 Real-Time Robotics & Guardrails: Gives physical controllers and backend APIs deterministic, low-latency feedback. 💡 The Analogy: Traditional LLMs act like a thoughtful essayist typing out a paragraph when you ask for a sentiment score. Jev acts like a instant touchscreen cashier: it emits {"sentiment": "positive", "confidence": 0.98} in 80 milliseconds. ⚠️ The Trade-offs: When NOT to use System One Models Giving up autoregressive string generation comes with clear boundary lines: 1️⃣ No Text Generation: Jev cannot write emails, draft code, or chat with users. It is strictly a decision engine, not a conversational assistant. 2️⃣ No Chain-of-Thought Visibility: Because evaluation happens in a single parallel pass, you lose readable, step-by-step reasoning traces. 3️⃣ Rigid Output Schemas: Decisions must fit pre-defined categorical schemas. It cannot improvise or hand-wave open-ended scenarios. System One models aren't replacing LLMs—they are replacing the fragile, slow string loops we built inside backend code. Are we renting expensive System 2 models for tasks that only need fast, rigid System 1 judgment? Ref: https://lnkd.in/eA4Af8QK #ArtificialIntelligence #SystemOne #MachineLearning #SoftwareArchitecture #Robotics #TypeSafeAI #techyvenki
-
Venkatesh Duvvuri reacted on thisVenkatesh Duvvuri reacted on thisFrom an idea to real quantum hardware — and now a Vanguard Industry Challenge Finalist 🚀 I’m excited to share that I’ve been selected as a Finalist for the WISER × Vanguard Industry Challenge Demo Day 2026. For the challenge, I explored a question I’ve been increasingly interested in: Can quantum computing generate useful portfolio candidates while classical optimization, business constraints, and independent validation remain the final authority? I built an end-to-end hybrid quantum-classical portfolio optimization prototype combining classical optimization, exact discrete benchmarking, stress testing, explainability, and quantum candidate generation. I also took the experiment beyond simulation and executed a reduced 17-logical-qubit QAOA formulation on real IBM Quantum hardware, collecting 12,288 hardware shots. A few results from the experiment: - 0.078% best-sampled gap from the exact discrete optimum - 3/3 hardware runs within 2% of the optimum - 36.59% mean feasible probability mass - Zero hard-constraint breaches in the reported best portfolios But the most interesting takeaway for me wasn’t simply running a quantum circuit. It was demonstrating a model where: Quantum generates candidates. Classical methods establish the benchmark. Independent validation decides what is acceptable. Humans remain in control. That is the direction I find most compelling for near-term enterprise quantum adoption—not replacing proven systems, but introducing quantum capabilities into governed, explainable decision workflows. A sincere thank you to The Washington Institute for STEM, Entrepreneurship and Research for creating this learning and innovation platform, Vanguard for bringing forward a meaningful industry challenge, IBM and IBM Quantum for the quantum platform and hardware ecosystem that enabled me to take the experiment from simulation to real hardware. Looking forward to presenting the work at Finalist Demo Day and learning from the other finalists and reviewers. #QuantumComputing #IBMQuantum #Vanguard #WISER #Qiskit #QuantumFinance #PortfolioOptimization #FinTech #Innovation #HybridComputing
-
Venkatesh Duvvuri liked thisVenkatesh Duvvuri liked thisIf you want to become a forward-deployed engineer, your portfolio needs to show how you solve a messy customer problem. I just created a video walking through 5 projects you can build to demonstrate that: 1/ A permission-aware enterprise knowledge system. Search across internal documents and support tickets, with access controls applied before information reaches the model. 2/ An intake-to-resolution workflow. Turn incoming requests into actions, with policy checks and human approvals that let you pause and resume the workflow. 3/ A document intelligence and approval system. Extract invoice details, verify them against purchase orders, and send exceptions to a reviewer. Let code handle the calculations and approval rules. 4/ A customer data onboarding pipeline. Map inconsistent customer data into your schema, validate it, and flag records that need fixing. 5/ An operations command center. Detect changes in operational metrics, explain what happened, and propose actions for a human to approve. For each project, I explain the customer problem, the architecture, what to evaluate, and what the work demonstrates to a hiring manager. You don’t need to build all five. My recommendation is to start with the first two and build them properly. Deploy them, document the failures, and explain your decisions. Watch the full video here https://lnkd.in/gmtACavn
-
Venkatesh Duvvuri liked thisFirst, Cursor built Origin a code editor re-imagined from the ground up for AI agents rather than human developers. Now comes Cloudflare Kitesurf a web browser built purely as an engine for AI. For years, running autonomous AI agents that browse the web meant shoehorning agentic workflows into general-purpose Chrome instances. We were paying heavy compute overhead for tabs, UI extensions, bookmarks, and local storage that an LLM agent simply doesn't need. The paradigm is shifting from Human Browsers to AI-Agent Engines: 🔹 Human Browsers (Chrome, Safari): Heavy binary apps designed for visual UI rendering, long-lived sessions, and human interaction. They pull 500MB–1GB+ RAM per tab. 🔹 AI-Agent Browsers (Cloudflare Kitesurf): Zero-Chromium, stateless execution layers built with Rust and WebAssembly that run directly inside V8 serverless isolates on edge networks. Key Kitesurf Highlights: ⚡ 3x–7x lower CPU/Memory footprint compared to standard Chromium. ⚡ Stateless Execution: Spins up, extracts DOM/screenshots, and tears down in milliseconds. ⚡ Agent-Native Protocols: Direct integration with Model Context Protocol (MCP) and Chrome DevTools Protocol (CDP). The Ecosystem Split: We are seeing two clear tiers of AI browsers emerge: * Agent Infrastructure (Backend): Headless execution layers like Kitesurf, Browserbase, and Steel built for LLM scraping, DOM parsing, and automated tasks. * Consumer-Facing AI Browsers (UI): Desktop browsers with embedded agents like Perplexity Comet, ChatGPT Atlas, and Arc/Neon. Just like IDEs evolved to agent-native environments, web infrastructure is now shifting to agent-native runtimes. The developer stack isn't just being upgraded for AI it's being completely rebuilt for it. Are you moving your agent automation workloads to lightweight edge runtimes yet? #Cloudflare #Kitesurf #AgenticAI #DevOps #CloudComputing #SoftwareEngineering #MCP #Serverless #techievenki
Experience
Education
Licenses & Certifications
-
The Data Scientist’s Toolbox
Coursera Course Certificates
-
Oracle Certified Professional Java SE 6 Programmer
-
Issued
Courses
-
Machine Learning
-
Projects
-
Quick View XP
Working on Spring MVC, Hibernate, Groovy & Grails and JavaScript Frameworks for a Telecom Domain Applications.
-
SSTS & SSTSE
-
SSTS: Application for managing and tracking biospecimen samples
SSTSE: Extensions/enhancements to STSS
There were couple of plugin-projects involved in SSTSE project. Those are Sstse-admin, Sstse-theme and Sstse-extenstion. Sstse-theme plugin project is to manage theme related stuff. Using this project you can create your own theme and upload resources like css, image for particular theme. Sstse-theme provides few default layouts, which can be used in host application.
Sample…SSTS: Application for managing and tracking biospecimen samples
SSTSE: Extensions/enhancements to STSS
There were couple of plugin-projects involved in SSTSE project. Those are Sstse-admin, Sstse-theme and Sstse-extenstion. Sstse-theme plugin project is to manage theme related stuff. Using this project you can create your own theme and upload resources like css, image for particular theme. Sstse-theme provides few default layouts, which can be used in host application.
Sample submission and tracking system developed using SSTSE-Theme plugin. SSTS administrator/researcher can search and filter libraries, view sample details, add sample, add libraries to sample dynamically. Generate samples report and export report. Administration also can able to upload samples.Other creators -
University of Miami informatics cloud
-
The primary Research and Technical Objective of the Cancer Genomics Cloud is to support the design, implementation, and documentation of a new model for computational analysis and sharing of very large biological data sets as well as learn about unforeseen obstacles. The ultimate goal is democratizing access to genomic data sets as well as providing sustainable computational support to the cancer research community.
Other creators -
Cooperative Group Bank
-
A key functionality of a new cooperative group informatics system will be to create a comprehensive, group wide, annotated inventory of available banked specimens that can be queried in order to quickly find appropriate sources of biospecimens for translational studies.
Technologies: Grails 2.1.1, Oracle 11g, JQueryOther creators -
Biospecimen Management System
-
Biospecimen management system (BMS) is a web application for managing bio specimens collected from participants who are enrolled into various clinical studies conducted by several research institutes. BMS integrates with caTissue, CALGB , STS which are used at the participating institutes, collection sites and respositories thus providing a single view and control point for them.
Other creatorsSee project -
Binja
-
Binja is a project administration tool that facilitates budget tracking, time and expense management for projects along with HR management and Invoicing. Binja is built for small and medium size enterprises and is offered as Software as a Service (SaaS) application
Other creatorsSee project
Honors & Awards
-
Standing Ovation Award
Equifax INC
Thanks for Equifax Team for recognizing me Standing Ovation Award.
-
Best Employee Award
Prokarma Softech
Got best employee award for 2014 Quarter III.
Languages
-
English
Full professional proficiency
-
Telugu
Native or bilingual proficiency
-
Hindi
Limited working proficiency
Recommendations received
6 people have recommended Venkatesh
Join now to viewOther similar profiles
Explore more posts
-
Arvind Sundara Rajan
As AI engineers, staying up-to-date with the latest trends and best practices is crucial for success in our field. The following YouTube videos offer valuable insights and practical takeaways on building AI apps, skills that AI can never replace, and emerging trends in AI agent frameworks and large language models. From strategies for improving app development and deployment efficiency to the importance of human intervention and software engineering expertise, these videos cover a wide range of topics relevant to AI/LLM engineers. ▶ "Building AI Apps In 2026" — Learn key strategies and best practices for building AI apps in 2026 and stay ahead in your field. https://lnkd.in/gRVTGwpa ▶ "Top skills AI can never replace" — Discover the key skills that AI and Large Language Models (LLMs) cannot replace and enhance your skills as an AI/LLM engineer. https://lnkd.in/gFZF5afD ▶ "Stop Learning n8n in 2026...Learn THIS Instead" — Find out why learning n8n may no longer be the best choice for AI/LLM engineers in 2026 and learn an alternative skillset that will drive innovation and growth in the field of automation. https://lnkd.in/gPqSzQFf ▶ "Notion Runs Thousands of AI Agents Internally (Here's How)" — Learn how Notion runs thousands of AI agents internally and enhance your own AI architecture with valuable lessons. https://lnkd.in/gE8eTUtk ▶ "Just built a self-healing AI portal where Claude writes the code ..." — Explore the integration of large language models and agents in a self-healing AI portal and learn about scalable and resilient system design. https://lnkd.in/g5pv_hBB ▶ "every AI PM needs to write evals, so here’s a healthcare ..." — Get insights on creating effective LLM evaluations and benchmarks, specifically in the healthcare sector, and learn about model deployment, fine-tuning, and AI model development in health technology. https://lnkd.in/g9HEgifr ▶ "OpenClaw vs PRAKTOR: Which AI Agent Framework Wins ..." — Compare OpenClaw and PRAKTOR AI agent frameworks and learn about performance, scalability, and applications to inform your framework selection decisions. https://lnkd.in/g3BBNMKG ▶ "How to write a perfect AI prompt. Complete Framework in 5 ..." — Get a comprehensive framework for crafting effective AI prompts and learn key considerations and best practices for successful prompt engineering in the field of artificial intelligence. https://lnkd.in/g7ecrt3M What are your thoughts on the latest trends in AI and LLMs? Let's discuss! #AI #LLM #AgenticAI #MachineLearning #YouTubeAI #ArvindSundararajan
-
Krishna C.
How saas companies address no reranking, so the best passage never makes the prompt and drive a search stack that grows with you with SuperChargeDB, the object-storage-native vector + document sear… SuperChargeDB — the object-storage-native, multimodal vector + document search engine by ZadeNor AI — brings semantic and hybrid search over text, documents and images to your app: automatic embeddings, neural reranking, grounded RAG with source citations, recommendations, and millisecond retrieval that scales on object storage without a cluster to babysit. Find anything by meaning, in milliseconds, at any scale. Read the full breakdown: https://lnkd.in/ebuubQEG Launch SuperChargeDB (start free): https://superchargedb.com Built by ZadeNor AI: https://www.zadenor.com SuperChargeDB is a search engine you add via one API — semantic, hybrid and multimodal retrieval from day one. #SuperChargeDB #VectorSearch #SemanticSearch #VectorDatabase #ZadeNor #SearchAI
-
Ajay Pillai
Putting together how fintech's can scale seamlessly between CPU, GPU/TPU and NPU The Four-Tier Latency Model Think of it as concentric circles, each adding latency but also capability: ┌─────────────────────────────────────────────────────────┐ │ TIER 1: Edge/CDN (0-5ms) │ │ • Cached responses, TLS termination, simple validation │ │ • Tech: CloudFront, Fastly, CloudFlare │ ├─────────────────────────────────────────────────────────┤ │ TIER 2: Edge Compute (5-20ms) │ │ • Lightweight inference, WebAssembly models │ │ • Tech: Lambda@Edge, CloudFlare Workers │ ├─────────────────────────────────────────────────────────┤ │ TIER 3: Regional Edge (20-40ms) │ │ • NPU-accelerated inference, medium models │ │ • Tech: AWS Local Zones, Inferentia │ ├─────────────────────────────────────────────────────────┤ │ TIER 4: Core Cloud (40-100ms) │ │ • Full GPU/TPU inference, complex ensembles, training │ │ • Tech: EC2 P4d/P5, GKE with A100, SageMaker │ └─────────────────────────────────────────────────────────┘ The Substrate Router decides in real-time which tier handles each request based on: • Latency budget remaining — How much time do we have? • Model complexity — How big is the model? • Current capacity — Which substrates have availability? • Cost optimization — Can we use cheaper compute? • Compliance — Does data residency require a specific region? The substrate router must answer: "Given this request, which compute substrate will deliver the result within the latency budget at the lowest cost?" Substrate Routing decisions INPUT: Inference Request example model_id: fraud-detection-v2, input_size_bytes: 2048, priority: high, compliance: data_recidency: US, pci_scope: true Routing Factors: 1. Model Characteristics: Size 450MB, Compatible substrate [CPU, GPU, NPU], Quantization: INT8 available for NPU 2. Substrate Availability: CPU Pool Capacity 45% QD 12, latency 35ms GPU (T4) Capacity 78% QD 48 latency 28ms GPU(Al0G) Capacity 92% QD 156 latency 45ms ← overloaded NPU(Inf2) Capacity 34% QD 8 latency 18ms ← best choice 3. Cost Weights: CPU: $0.05/hr → $0.000014/req, GPU: $0.53/hr → $0.000147/req, NPU: $0.36/hr → $0.000100/req 4. Compliance Constraints Data must stay in US region, PCI-DSS requires audit logging, No processing on shared/spot instances OUTPUT: Route to NPU(Inferentia) in us-east-1
-
Suri CM
🚀📚Multi-agent AI system - Reference Architecture Interesting read from Google Cloud on the architecture of multi-agent AI systems. The key idea is to break down complex problems into smaller tasks, with specialised AI agents working together to find a solution. 📚The article provides a reference architecture and explores real-world use cases like financial advising, research assistance, and supply chain optimisation. It's a great resource for anyone looking to build more sophisticated and collaborative AI solutions. 🚀 💪 Link to article in comment 👇 #AI #MultiAgentSystems #GoogleCloud #ArtificialIntelligence #Innovation #AgenticArchitecture #AgenticAI
3 Comments -
Simardeep S.
𝗚𝗞𝗘 𝗣𝗼𝗱 𝗦𝗻𝗮𝗽𝘀𝗵𝗼𝘁𝘀 𝗦𝗼𝗹𝘃𝗲 𝘁𝗵𝗲 𝗚𝗣𝗨 𝗔𝘂𝘁𝗼𝘀𝗰𝗮𝗹𝗶𝗻𝗴 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗳𝗼𝗿 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗔𝗜 Google Cloud GKE Pod snapshots solve a specific problem for workloads with long initialization times. Large language models that take 8-10 minutes to load into GPU memory create capacity gaps when autoscaling triggers. New replicas take just as long to start, leaving users waiting. Pod snapshots capture the complete runtime state of a running pod including memory, GPU state, and filesystem changes. New replicas restore from that snapshot instead of cold starting. This turns 10 minute initialization into sub-second warm starts. The implementation uses gVisor's checkpoint and restore capabilities. The kernel loads first, the application resumes immediately, and memory streams in the background. Page faults trigger on-demand fetching for any memory not yet loaded. This creates instant apparent startup while full synchronization happens asynchronously. From an enterprise architecture perspective, this makes autoscaling viable for GPU inference workloads that previously could not scale effectively. The feature requires GKE Sandbox, Cloud Storage with hierarchical namespaces, and Workload Identity Federation. Snapshot size optimization is critical when dealing with hundred-gigabyte model files. This is not for typical stateless services. The operational overhead only makes sense for workloads with genuinely long initialization times. But for LLM inference servers, scientific computing platforms, or heavy data processing systems, the performance improvement is substantial. Full technical implementation here: https://lnkd.in/eGhTEvp6
-
Shubham Sharma
Interesting perspective from a recent paper comparing fine-tuned SLMs vs. prompted LLMs for generating low-code workflows. We often default to using LLMs for almost everything — usually with RAG layered on top. The findings suggest that a well-tuned smaller model might outperform a larger one in certain cases, especially where accuracy and domain focus matter. A good reminder that model size isn’t the only lever worth considering. https://lnkd.in/dNG4ZZa9
-
Sandeep Pawar
💡ICYMI: With the recently updated #AIFunctions in #MicrosoftFabric, you can specify response_format parameter to generate LLM response that conforms to the specified schema. ❓Why does that matter ? Because it ensures downstream application readiness with type safety and constraints. You can even use Pydantic models (Pydantic models are very powerful, check out my previous blogs but new blog soon on how to use it). For example, in my blog below, I explicitly entered the schema in the prompt. ❌No more. Just specify it as a part of your function and you are guanarteed to get the specified schema -> Enterprise ready ! 📌https://lnkd.in/gzVpXtJ5 🔗Learn more : https://lnkd.in/gqAy4nZH 🔥As always, you don't need to provision anything. Works out of the box. The fastest, easiest and scalable features to get started with AI for your data.
2 Comments -
Deven Reddy
Cloud engineers automated deployments, scaling, and recovery. Yet for some reason, we are still manually taking screenshots for compliance. It’s the last manual mile in the cloud, and it’s killing team velocity. Cloud & infra teams get pulled into audits for one reason: they’re the only place the evidence lives. So engineers become the middleman. · Screenshots. · One-off queries. · Digging up logs from "last quarter." It breaks flow and adds zero operational value. What actually works: 1️⃣ Evidence becomes self-serve If data is timestamped and available for GRC and auditors on demand, engineers don’t need to be looped in every time a question comes up. 2️⃣ Engineers stop being translators Cloud teams shouldn’t have to explain configs or permissions to auditors. The data should speak for itself. 3️⃣ History > Snapshots Audits Historical record proves posture over time. If you can’t rewind, you’re stuck chasing screenshots. 4️⃣ Shared visibility reduces friction When everyone looks at the same source of truth, conversations shift from "did you do this?" to "what changed and why?" The outcome is simple: Infra teams stay focused on running the cloud. Evidence is always ready. Audits stop being disruptive. Is your cloud team still spending their time taking screenshots and working for auditors and compliance?
1 Comment
Explore top content on LinkedIn
Find curated posts and insights for relevant topics all in one place.
View top content