Idea Forge: Automated Full-Stack Web Application Generation from Natural Language

International Research

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net p-

Idea Forge: Automated Full-Stack Web Application Generation from Natural Language

Sreeya Dora¹, Madhura Bedekar², Vivia Maria Thomas³, Chetan Navhi´

¹²³´ B.Tech. Student, Department of Computer Science and Engineering M S Ramaiah University of Applied Sciences, Bengaluru, India (¹² AIML Branch | ³´ CSE Branch)

Abstract Building a functional web application requires coordinated expertise across database design, server-side engineering, andclient-side developmentabarrierthatremains out of reach for most non-programmers and time-intensive even for experienced developers. This paper presents IdeaForge, an intelligent full-stack web application generation platform that automatically converts natural language descriptions into immediately executable, fully functional web applications. The system integrates afive-stagepipeline comprising an IntentParser, Feature Extractor, Template Mapper (AI Module), Code Generator, and Database Module, producing a FastAPI backend with SQLite persistence and a responsive HTML/JavaScript frontend. A central engineering contribution is a two-tier schema generation mechanism that combines a Large Language Model (Claude API) with a deterministic rule-based keyword fallback, ensuring reliable schema production under both normal and degraded API conditions. The platform further incorporates role-based user and admin dashboards, authentication, and multiapplication management. A controlled preliminary evaluation across 35 multidomain prompts reports field-level precision of 91.3% under LLM-assisted operation and 84.2% under the fallback tier, with end-to-end generation completing in under ten seconds. A usability study with 15 participants yields mean Likert scores above 4.2/5 across all dimensions. These results demonstrate IdeaForge as a practical instrument for rapid prototype development, significantly reducingthebarriertosoftwarecreationfornon-technicalusers.

Keywords naturallanguageprocessing,largelanguagemodels, automated code generation, full-stack web applications, FastAPI, SQLite, schema inference, prototype generation, no-code development, reliability engineering, authentication, role-based access

1. INTRODUCTION

Contemporary web application development demands simultaneousproficiencyacrossatleastthreedistincttechnology layers: relational database design, RESTful API engineering, and client-side interface construction. The interdependence of these layerscompoundsdevelopmenteffortconsiderablyandcreatesa significantbarrierfordomainexpertsresearchers,entrepreneurs, and subject-matter specialistswho possess deep knowledge of a problem yet lack the programming fluency to implement a software solution [7]. Industry reports consistently identify this multi-stack requirement as the foremost bottleneck in rapid prototyping.

Low-codeandno-codeplatformsofferpartialrelief.Toolssuchas OutSystems, Mendix, and Bubble allow application assembly through visual composers, reducing but not eliminating the

learning curve. More critically, these tools lock users into proprietary abstractions, constrain them to vendor-defined feature sets, and do not produce open, inspectable source code that a developer can extend. Recent LLM-based coding toolsGitHub Copilot [4], CodeGen [5], and their successorsdemonstrate strong capability at function-level code generation but presuppose an existing project structure and a developerwhocanevaluateandintegratethegeneratedoutput.

IdeaForge addresses a fundamentally different need. It can be viewedasaconstrainedsynthesissystemwherenaturallanguage serves as an informal specification and template-guided generationenforcesstructuralcorrectness.constrainedsynthesis system where natural language serves as an informal specification and templateguided generation enforces structural correctness. The core contribution of IdeaForge is a reliabilityfocused hybrid schema generation mechanism embedded within an end-to-end NL-to-application pipeline. Three design properties support this contribution: (i) end-to-end scopespanning intent parsing through database initialisation to deliver a runnable prototype; (ii) reliable generationa rulebased fallback guarantees schema delivery even when the LLM API is unavailable; and (iii) zero configurationthe user supplies only a natural language string with no forms, DSLs, or programmingknowledgerequired.

The platform additionally provides a multi-user environment with JWT-based authentication, role-based access control distinguishing regular users from administrators, and a persistent application library where each generated app can be launched, modified, or regenerated on demand. This positions IdeaForge not merely as a code generator but as a complete applicationdevelopmentandmanagementecosystem.

Theresearchcontributionsofthispaperare:

1. A complete five-stage NL-to-deployableapplication pipeline integrating intentparsing,schema inference,template-driven codegeneration,andautomaticdatabaseinitialisation.

2. A two-tier hybrid schema generation mechanism combining LLM inference (Claude API) with a deterministic keyworddriven fallback, ensuring schema production under simulatedAPIunavailabilityconditions.

3. A multi-user platform environment with JWT authentication and persistent application lifecycle management, enabling iterative refinementacrosssessionsa property notpresentin single-shotcodegenerators.

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

4. A controlled preliminary evaluation across 35 multi-domain prompts with baseline comparison, error categorisation, and a usability study across technical and non-technical user groups.

2. RELATED WORK

2.1

Pre-trained Models for Code

CodeBERT [1] established that joint pre-training over natural language and source code corpora produces representations suitable for code search and documentation generation. Codex [3], CodeGen [5], and AlphaCode [6] extended this to code completion and competitive programming, achieving humancompetitive results on algorithmic benchmarks. These systems operate at the function or class level and do not orchestrate multiple interdependent source files into a single, runnablemulti-layerwebapplication.

2.2 LLM Coding Agents

The few-shot generalisation of GPT-3 [2] and successors demonstrated that LLMs can follow complex, multi-step instructions. Applied to software engineering, this capability powers tools such as GitHub Copilot [4] and AI-assisted programming environments [8]. These tools assist professional developers within existing projects, presupposing a developer capable of integrating and debugging generated fragments. They are not designed for users who have no programming backgroundandnoexistingprojectstructure.

2.3 No-Code and Low-Code Platforms

Commercial no-code platforms such as Bubble, Webflow, and AppGyver allow visual construction of web applications. While they democratisesurface-levelcreation,they impose proprietary runtimes, limit extensibility, and require users to learn platformspecific paradigms. They do not produce deployable source code. IdeaForge differs by generating standard, opensource-framework code (FastAPI, SQLAlchemy, HTML/CSS/JS) that users can inspect, modify, and deploy independently.

2.4 Program Synthesis

Classical program synthesis derives programs from formal specifications [9], offering correctness guarantees at the cost of requiring formal input languages inaccessible to nonprogrammers. Recent surveys [7][10] document a transition towardLLM-drivensynthesis,identifyingreliabilityunderservice failure and structural completeness across multi-file projects as primary open challenges. IdeaForge addresses both through its template-grounded code generation and two-tier fallback mechanism.

The prior literature leaves a clear gap: no existing system combines open natural language input, schema-level entity inference, template-driven multi-file code generation, database initialisation, and multi-user management into a pipeline that reliablydeliversarunnableprototype.IdeaForgefillsthisgap.

3. SYSTEM ARCHITECTURE

Figure 1 presents the IdeaForge system architecture. The platform is structured around three principal layers: an Authentication Layer managing user and admin access with rolebasedrouting;theApplicationEngineexecutingthefive-stage generation pipeline; and a persistence layer comprising a SQLite database and the Generated Application. Figure 2 illustrates the completeoperationalflowforbothuserandadminroles.

3.1 Authentication Layer

The Authentication Layer handles registration, login, and role assignment using JWT-based authentication. The key design decision here is stateless token validation: each protected API request carries a signed JWT, eliminating server-side session storage and enabling horizontal scalability. Role assignment at registration time (user or admin) determines all subsequent routingandaccesspermissions.

3.2 User Dashboard

TheUserDashboardexposesthreecapabilities:GenerateApp,My Apps, and View Stats. The design decision to persist generated applications in a library rather than discarding them after generation is central to the platform’s utility users can return, re-run,anditerativelyrefineapplicationsacrosssessions.

3.3 Admin Dashboard

The Admin Dashboard provides platform-level oversight across three views: Overview (system-wide statistics), Manage Users (account activation and deactivation), and Manage All Apps (cross-user application inspection and removal).Role separation is enforced at the JWT level, ensuring that admin-scoped API endpoints reject requests from non-admin tokens regardless of client-sidestate.

3.4 Application Engine

TheApplicationEngineisthecomputationalcoreofIdeaForge.It accepts the application name and natural language prompt from

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

the User Dashboard and executes a five-stage pipeline: Intent Parser → Feature Extractor → Template Mapper (AI Module) → Code Generator → Database Module. Each stage is described in Section 3.5–3.10. The engine outputs a complete application directorythatisregisteredinthedatabaseandmadeavailablein theuser’sMyAppslibrary.

3.5 Input Handler

The Input Handler accepts the application name and natural language prompt, sanitises inputs, enforces length constraints, and forwards a structured request to the AI Module. No domainspecific syntax or prior programming knowledge is requiredfromtheuseratthisstage.

3.6 AI Module (Claude API)

The AI Module submits a structured meta-prompt to the Anthropic Claude API with temperature set to zero, instructing the model to return a validated JSON schema specifying entity names,fieldnames,andprimitivedatatypes({text,number,date, boolean}). The response is validated against the IdeaForge schemaspecification.Onsuccess,theschemaadvancestoFeature Extraction. On failure, control passes silently to the Rule-Based Parser.

3.7 Rule-Based Parser (Fallback)

IftheAIModulefailsorreturnsmalformedJSON,theRule-Based Parser activates transparently. A multi-pass lexical scan scores each entry in the domain-keyword lexicon by matched token count.Thehighest-scoringdomaintemplateismaterialisedasthe schema. The user is never exposed to an error state, ensuring continuousavailabilityofthegenerationpipeline.

3.8 Feature Extraction

The Feature Extractor determines candidate entities implicit in the schema (e.g., expense, exercise session, product) and their application type (Finance, Health, Commerce, Productivity). Field-type bindings are resolved: a date field maps to a Python datetime.date column; a boolean mapstoa SQLAlchemy Boolean columnwithacheckboxwidgetinthefrontend.

3.9 Template Mapping and Code Generator

The Template Mapper selects appropriate Pydantic schema templates, SQLAlchemy ORM model templates, and CRUD route templates for each entity. The Code Generator emits app.py (FastAPIapplication,routeregistration,CORS,databasebinding), routes.py (five CRUD handlers per entity), and a static HTML/CSS/JavaScript frontend providing data-entry forms, paginatedtables,andChart.jsvisualisationsfornumericfields.

3.10 Database Module and Generated Application

The Database Module executes SQLAlchemy model definitions againstaSQLite file,creating allrequired tablesandindices.The Generated Applicationa self-contained FastAPI scaffold with SQLite database and static frontendis assigned a port, registered intheplatformdatabase,andaddedtotheuser’sMyAppslibrary readyforimmediatelaunch.

4. SYSTEM WORKFLOW

The IdeaForge workflow is designed to be linear and intuitive, requiring no technical expertise from the user. The complete endto-endflowfromuserlogintoarunningapplicationproceeds through six distinct phases asdescribed below and illustrated in Fig.2.

4.1 Authentication Phase

The user navigates to the IdeaForge portal and selects either Login or Register. New users provide a username, email, and password; the system hashes the password (bcrypt), creates a user record in the SQLite users table, and issues a signed JWT with a configurable expiry. Returning users authenticate with their credentials; the JWT is validated and the role field (user or admin)determinesthesubsequentrouting.

4.2 Application Specification Phase

Upon reaching the User Dashboard, the user enters two inputs: (i) an Application Name (e.g., “Smart Study Planner”) which serves as the project identifier and directory name; and (ii) a natural language Description of the desired application (e.g., “Track study sessions by subject, allow marking tasks as complete, and show overall progress as a percentage”). No further input is required. The user clicks “Generate App” to initiatethepipeline.

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

4.3 AI Processing Phase

TheApplicationEnginereceivesthe(name,description)pair.The Input Handler sanitises and validates both fields. The AI Module thenconstructsastructuredmeta-promptandqueriestheClaude API. The API response is parsed and validated against the IdeaForge JSON schema specification. If valid, the structured schema is passed to Feature Extraction. If invalid or unavailable, the Rule-Based Parser activates to produce a schema deterministicallyfromkeywordmatching.

4.4 Code Generation Phase

The validated schema flows through Feature Extraction (entity andtyperesolution),TemplateMapping(selectionofappropriate FastAPI, Pydantic, and SQLAlchemy templates), and Code Generation (emission of app.py,routes.py,and the HTML/CSS/JS frontend).Allfiles are written to a projectdirectory namedafter the application. The Code Generator also produces a requirements.txtandalaunchscript.

4.5 Database Initialisation Phase

TheDatabaseModuleimportsthegeneratedSQLAlchemymodels and executes create_all() against a fresh SQLite file within the project directory. All entity tables, primary key indices, and any configured default data are created. The application record is then registered in the platform’s central database (application name,owner,creationtimestamp,portassignment,anddirectory path).

4.6 Application Lifecycle Phase

The newly generated application appears in the user’s My Apps library.The user can: (i) click“Run” to launchthe applicationon its assigned port, exposing the CRUD UI immediately; (ii) click “Modify” to update the prompt and regenerate the application with revised specifications; or (iii) click “Delete” to remove the applicationanditsassociateddatabase.Adminusersadditionally haveaccesstoaplatform-wideAppsviewwhereanyapplication canbeinspectedorremoved.

5. HYBRID SCHEMA GENERATION MECHANISM

Reliable schema production is the most critical availability requirement in IdeaForge. LLM API services are subject to rate limits,networktimeouts,andplannedorunplannedoutages.The two-tier hybrid mechanism addresses this directly, ensuring a validschemaisalwaysproduced.

5.1

Tier 1 LLM-Assisted Generation (Claude

API)

A structured meta-prompt is submitted to the Anthropic Claude APIwithtemperaturesettozero.Thepromptinstructsthemodel to analyse the user description and return a JSON object conforming to the IdeaForge schema specification: a single toplevel entity with a name string and an array of fields, each specifying a field name and a type drawn from {text, number, date, boolean}. The response is validated against this specification using a local JSON schema validator. On successful

validation, the schema advances to Feature Extraction and TemplateMapping.

5.2 Tier 2 Rule-Based Parser (Keyword Fallback)

IftheAPIcallfailsorthereturnedJSONfailsvalidation,theRuleBased Parser activates without user notification. A multi-pass lexicalscancomputesamatchscoreforeachdomaintemplatein thekeywordlexiconbasedonthecountofmatchedtokensinthe user description. The domain with the highest score is selected and its associated field template is instantiated as the schema. Table1presentsrepresentativedomain-keyword-fieldmappings.

Table -1: Keyword-to-Template Mappings (Fallback Tier)

Domain Trigger Keywords Generated Fields (sample)

Finance expense,budget, cost,spend category:text,amount:number, date:date,note:text,paid: boolean

Health gym,workout, exercise,fitness exercise:text,sets:number,reps: number,weight:number,date: date

Productivity study,task, planner,goal subject:text,duration:number, priority:text,due_date:date, done:boolean

Commerce inventory,stock, product item:text,quantity:number,price: number,supplier:text,reorder: boolean

Subscription subscription, renewal,service service:text,cost:number, renewal_date:date,active: boolean,tier:text

5.3 Schema Validation and Type Resolution

Regardlessofthetierthatproducedtheschema,allschemaspass throughacommonvalidationandtype-resolutionstep.Eachfield type is mapped to its corresponding Python/SQLAlchemy type (text→String, number→Float, date→Date, boolean→Boolean) and its corresponding HTML input widget (text→input[text], number→input[number], date→input[date], boolean→input[checkbox]). Type mismatches detected at this stage trigger fallback to the default text type, preventing downstreamcodegenerationerrors.

6. WORKED EXAMPLE

Table 2 traces a complete user interaction through IdeaForge fromlogintoarunningapplication.Theuserenterstheappname "SmartStudyPlanner"andaplain-Englishdescription,thenclicks "Generate App" the entire pipeline executes automatically in undertenseconds.

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

1.Login Userauthenticatesviatheportal;JWTissued;User Dashboardloaded

2.AppName "SmartStudyPlanner"

3.Description "Trackstudysessionsbysubject.Marktaskscomplete. Showprogress%."

4.Generate App Userclicks"⚡GenerateApp";ApplicationEngine invoked

5.AIModule ClaudeAPIreturnsschema:{subject:text,task:text, due_date:date,completed:boolean,progress:number}

6.CodeGen app.py+routes.py(5CRUDendpoints)+index.html (form,table,Chart.jsprogressbar)emitted

7.Database study_planner.dbcreated:tablestudy_planner(idPK, subject,task,due_date,completed,progress)

8.MyApps Appregistered;appearsinuser’s"MyApps"library

9.Run UserclicksRun→uvicornlaunchesonassignedport→ CRUDUIaccessibleinbrowser

10.Modify Userupdatesdescriptiontoadda“notes”field→clicks Regenerate→schemaupdated,apprebuilt

7. KEY FEATURES

 Zero-configurationinput:plainEnglishappdescriptiononly; noforms,DSLs,orprogrammingknowledgerequired.

 JWT-based authentication with role-based access control (User/Admin)andpersistentsessionmanagement.

 Automatic schema inference across four primitive field types:text,number,date,andboolean.

 Complete FastAPI backend: five CRUD endpoints per entity, CORSconfiguration,andSQLAlchemyORMintegration.

 Automatic SQLite initialisation: table creation, indexing, and optionaldataseedingwithoutuserintervention.

 Responsive frontend: form-based data entry, paginated tabulardisplay,andChart.jsvisualisationsfornumericfields.

 Reliable two-tier schema generation (LLM + rule-based fallback) achieving high generation reliability across all evaluatedconditions.

 Persistentapplicationlibrary:MyAppsdashboardwithRun, Modify,andDeletelifecyclecontrols.

 Admin platform management: user oversight, system-wide appmanagement,andusageanalytics.

 Modularpipeline:eachstageindependentlyreplaceable(e.g., swapSQLiteforPostgreSQL,orReactforstaticHTML).

8. EVALUATION

8.1 Experimental Setup

A controlled preliminary evaluation was conducted using 35 natural language prompts spanning five application domains (seven per domain: Finance, Health & Fitness, Productivity, Commerce,andSubscriptionManagement).Promptsrangedfrom a single sentence to three sentences with explicit field constraints. Ground-truth schemas were independently annotated by two domain experts; inter-annotator agreement was 94.3% (Cohen’s κ = 0.91). All experiments were conducted on a consumer laptop (Intel Core i5, 16 GB RAM, Python 3.11, FastAPI 0.110). While the evaluation scale is limited, it is designed as a controlled preliminary study to validate system behaviour across representative domains and establish baseline metricsforfuturelarge-scaleassessment.

8.2 Schema Accuracy

Field-level precision and recall were computed against groundtruth annotations. Under LLM-assisted generation, IdeaForge achievedprecisionof91.3%andrecallof88.7%.Underkeywordfallback generation (activated by disabling the API endpoint), precision was 84.2% and recall was 79.6%. Across all 35 trials and both tiers, a valid schema was produced in every case, yieldinga100%generationsuccessrate.Nopromptresultedina systemerrororemptyoutput.

8.3 Baseline Comparison

Table 3 compares IdeaForge against three baselines. The LLMOnly baseline was evaluated by disabling the fallback subsystem andinducingAPIunavailabilityfor10of35promptsvianetworklevel blocking; all 10 produced no schema. Manual development latency is estimated from prior benchmarks [4][8] and is not directly measured in this study. Manual development estimates are derived from prior studies on equivalent CRUD application construction and are presented as indicative benchmarks rather than directly comparable measurements. The GitHub Copilot comparisonisqualitativeasittargetsdeveloperassistancewithin anexistingproject.

Table -3: Comparison with Baseline Approaches

GitHubCopilot N/A N/A Hours Yes N/A

ManualDev 100% 100% 8-40h Yes 0

*LLM-Onlyprecisioncomputedoverthe25/35promptsthatproduceda schema.Manuallatencyestimatedfrompriorbenchmarks[4][8].

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

8.4 Generation Latency

Mean end-to-end latency from prompt submission to a locally launchable applicationdirectory was8.4 s(σ = 1.9 s)underLLMassisted generation and 1.1 s (σ = 0.2 s) under keyword-fallback operation. Both represent reductions of multiple orders of magnitude relative to manual development estimates of 8–40 hours for an equivalent CRUD prototype by an experienced developer.

8.5 Usability Study

Fifteen participants five professional software developers, five undergraduate students in non-CS disciplines, and five domain professionals with no programming background evaluated IdeaForge on a five-point Likert scale across four dimensions. Table4reportsper-groupscores.All15participantssuccessfully generatedaworkingprototypeontheirfirstattemptwithoutany guidanceordocumentation.

Table -4: Usability Study Results (Likert 1–5, n = 15)

9. ERROR ANALYSIS AND LIMITATIONS

Threeerrorcategorieswereidentifiedacrossall35testprompts and both tiers. Table 5 summarises frequency, active tier, root cause,andplannedremediationforeach.

Table -5: Error Category Summary

Wrongfield type 12%of fields Fallback

of prompts

typehints

bypassestype rules

assumptionin templatelib

mapper Overgeneration

of prompts

9.1 Wrong Field Type

only LLMinfers unstatedbut plausible fields

confirmation

used indirect phrasing (e.g., "the cost in words"). The LLM tier exhibited this in fewer than 2% of fields, as sentence-level contextualreasoning suppressed mosttypeambiguities.Planned fix: introduce a post-schema contextual type-hint layer that reevaluatesfieldnamesagainstacuratedtype-indicatorlexicon.

9.2 Missing Entity

When a prompt referenced two or more distinct entities in a singlecompoundsentence(e.g.,"trackbothmyworkoutsandmy diet"), the system occasionally inferred only the first entity. This stems from the single-entity assumption in the current template library. Multi-entity schema support allowing one prompt to generatemultiplerelatedtableswithforeign-keyrelationships isaprimaryplannedenhancement.

9.3 Over-generation

InasmallnumberofcasestheLLMinferredadditionalfieldsnot mentioned by the user (e.g., generating note and tags fieldsfor a minimal prompt). While often contextually reasonable, these deviate from strict user intent. A post-generation fieldconfirmation dialogue is under consideration, allowing users to accept,remove,orrenameinferredfieldsbeforecodegeneration proceeds.

9.4 Scope Limitations

IdeaForge produces prototype-level applications suitable for early-stage evaluation and personal use, not production deployment. The field-type vocabulary covers four primitives; enumeration fields, file-upload references, and multi-table relational foreign keys are not yet supported. The preliminary evaluation(35prompts,15usabilityparticipants)isintentionally scoped; expansion to 100+ prompts across a wider domain distributionisapriorityforfuturework.

10. DISCUSSION

The baseline comparison in Table 3 reveals the central value propositionofthehybriddesign.TheLLM-Onlybaselineachieves equivalent schema quality when the APIisavailable butincursa 28.6% generation failure rate under induced unavailability. IdeaForgeeliminatesthisfailuremodeatamodestaccuracycost of approximately 7 percentage points in precision when the fallback tier activates. This trade-off is intentional: for a tool targeting non-programmers, a slightly imprecise schema that generatesaworkingscaffoldisfarpreferabletoasystemerror.

The usability data reveal an important insight: domain professionals achieved the highest output-quality scores (4.4/5), suggesting that describing an application in domain vocabulary ratherthantechnicaltermsisanadvantageratherthanaliability when interacting withIdeaForge.Thisdirectly validatesthe core design premise that natural language is the appropriate input modalityforthisclassofuser.

The most frequent error under keyword-fallback generation. A "price" field was occasionally classified as text when the prompt

Compared with manual development, IdeaForge reduces prototype delivery time from hours to seconds for the domain typesinourevaluationset.ThegeneratedFastAPIscaffoldpasses syntaxvalidationandexecuteswithout modification,providing a meaningful starting point for further development. The trade-off is constrained customisability: the generated application is

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

bounded by the current template library. The modular architectureisdesignedtomitigatethisbyallowingtemplatesto beextendedwithoutmodifyingthecorepipeline.

The multi-user platform layer authentication, role-based dashboards, and persistent application management distinguishes IdeaForge from single-shot code generators. Users can return to the platform, launch previously generated applications, and iteratively refine their specifications. This lifecycle-oriented design is essential for practical adoption in teamandclassroomenvironments.

11. CONCLUSION

This paper presented IdeaForge, an intelligent platform that automatically converts natural language application descriptions into immediately executable full-stack web applications. The platform integrates a five-stage Application Engine with a twotierhybridschemagenerationmechanism,JWT-basedmulti-user authentication, role-based dashboards, and a persistent applicationlifecyclemanagementsystem.

A controlled preliminary evaluation across 35 multi-domain prompts demonstrated field-level precision above 84%, 100% generation success across both tiers, sub-ten-second end-to-end latency, and usability scores above 4.2/5 across technical and non-technical user groups. All 15 usability study participants successfullygeneratedaworkingprototypeontheirfirstattempt. IdeaForge is intended as a rapid prototype development tool rather than areplacementforprofessionalsoftwareengineering. Itsprincipalcontributions thereliability-focusedhybridschema generation mechanism, the end-to-end five-stage pipeline, and the multi-user platform architecture represent concrete advances toward making early-stage software prototyping accessible to users without programming expertise. This work was carried out as part of a B.Tech. final year project at M S RamaiahUniversityofAppliedSciences,Bengaluru.

12. FUTURE WORK

 Multi-entity schema support: generating multiple related tables with foreign-key relationships from a single compoundprompt.

 OAuth 2.0 / JWT authentication scaffolding embedded directly into generated applications, enabling secure multiuseraccess.

 One-clickclouddeploymentviaDockercontainerisation and CI/CDpipelinegenerationtargetingAWS,GCP,orAzure.

 Extended field-type vocabulary: enumeration columns, fileupload references, geographic coordinates, and rich-text fields.

 Domain-adaptivefine-tuningofacompact,locallydeployable LLMtoreduceAPIdependency,inferencelatency,andcost.

 Expanded evaluation: 100+ prompt corpus across a wider domain distribution with a formally recruited and counterbalancedusabilitycohort.

 Production framework export: code translation targeting Django REST Framework, Spring Boot, or Next.js for teams requiringproduction-gradeoutput.

 Real-time collaborative workspace: shared project environments with concurrent editing, version history, and conflictresolution.

ACKNOWLEDGEMENTS

Theauthorsgratefullyacknowledgetheguidanceandmentorship of Dr. Venkata Giri J, Department of Computer Science and Engineering, M S Ramaiah University of Applied Sciences, Bengaluru, for his valuable support, insights, and continuous encouragementthroughoutthe developmentof thisproject.This work was undertaken as part of the B.Tech. Computer Science and Engineering Final Year Project (2024–25) at M S Ramaiah UniversityofAppliedSciences,Bengaluru,India.

REFERENCES

[1] F. Feng et al., "CodeBERT: A Pre-Trained Model for Programming and Natural Language," Proc. EMNLP, pp. 1536–1547,2020.

[2] T. Brown et al., "Language Models are Few-Shot Learners," NeurIPS,vol.33,pp.1877–1901,2020.

[3]M.Chenetal.,"EvaluatingLargeLanguageModelsTrainedon Code,"arXiv:2107.03374,2021.

[4]A. Yetistiren, I. Ozsoy, and E. Tuzun, "Evaluating the Code Generation Capability of GitHub Copilot," ACM SIGSOFT, pp. 1–5,2022.

[5] S. Nijkamp et al., "CodeGen: An Open Large Language Model forCodeGeneration,"arXiv:2203.13474,2022.

[6]Z. Li et al., "Competition-Level Code Generation with AlphaCode,"Science,vol.378,no.6624,pp.1092–1097,2023.

[7]Y. Wang et al., "A Survey on Large Language Models for SoftwareEngineering,"IEEETrans.Softw.Eng.,2023.

[8]H. Wong and J. Guo, "AI-Assisted Programming using Large Language Models," IEEE Software, vol. 41, no. 1, pp. 45–53, 2024.

[9]J. Austin et al., "Program Synthesis with Large Language Models,"ACMComput.Surv.,vol.57,no.2,pp.1–36,2025.

[10]K. Zhu et al., "Generative AI for Automated Software Development,"IEEEAccess,vol.13,pp.45678–45690,2025.

BIOGRAPHIES

Sreeya Dora isafinal-yearB.Tech.student(AIML branch) in the Department of Computer Science and Engineering at M S Ramaiah University of Applied Sciences, Bengaluru. Her research interestsincludenaturallanguageprocessing,AIdriven development tools, and full-stack engineering.Shecontributedtosystemdesign,AI integration, and frontend development of IdeaForge.

Volume: 13 Issue: 04 | Apr 2026 www.irjet.net

Madhura Bedekar isafinal-yearB.Tech.student(AIML branch) in the Department of Computer Science and Engineering at M S Ramaiah University of Applied Sciences,Bengaluru.Sheservedastheprimarybackend developer of IdeaForge, responsible for designing and implementing the FastAPI server, SQLite database architecture,CRUDroutinglogic,ClaudeAPIintegration, andtherule-basedfallbackmechanism.

Vivia Maria Thomas isafinal-yearB.Tech.student(CSE branch) in the Department of Computer Science and Engineering at M S Ramaiah University of Applied Sciences,Bengaluru.Her contributionsinclude frontend development, template mapping design, and usability testingoftheIdeaForgeplatform.

Chetan Navhi is a final-year B.Tech. student (CSE branch) in the Department of Computer Science and Engineering at M S Ramaiah University of Applied Sciences, Bengaluru. His contributions include evaluation design, baseline comparison methodology, erroranalysis,andprojectdocumentationforIdeaForge.