My GitHub profile is under the name Arjun Singh Naruka, with the username @arjunji123. I have been on GitHub since 2021 and have 6 followers. This profile complements my professional background on arjun singh naruka linkedin profile.
I describe myself as a passionate Full Stack Developer specializing in the MERN stack. I build dynamic web applications with MongoDB, Express.js, React.js, and nodejs.
In the README for my arjunji123 repository, started in 2024-06 and last updated in 2025-07, I describe my work as building dynamic, user-friendly web applications, solving complex problems, and continuously learning new technologies.
- My listed frontend technologies are HTML, CSS, JavaScript, React.js, Redux, and Next.js.
I am exploring cloud services and microservices architecture, integrating machine learning into web applications, and contributing to and learning from the open-source community.
I welcome collaboration on interesting projects, discussions about ideas, and conversations about technology. I share my professional profile on arjun singh naruka linkedin profile and can be contacted at singhnarukaarjun@gmail.com.
Outside coding, I follow technology trends and look for ways to use them in my projects; I also read about AI and experiment with recipes.
- My listed backend technologies are Node.js, Express.js, and Nest.js; my listed databases are MongoDB, SQL, and PostgreSQL.
- I list Docker and CI/CD under DevOps, Git, Webpack, Babel, and VS Code as tools, and Passport.js for authentication and Mapbox for interactive maps.
- Repositories shown on my profile, with listed language and last-updated date: Freshbhoj-website — TypeScript, 2026-11; Portfolio — TypeScript, 2026-10; FreshBhoj---App — Kotlin, 2026-10; Freshbhoj---Backend — TypeScript, 2026-10; tax-document-collection-assignment — Python, 2026-09; Subhdin — TypeScript, 2026-08; Subhdin_be — TypeScript, 2026-08; hire-my-idea-assignment — JavaScript, 2026-03; luca-voice-agent — JavaScript, 2026-01; elegant_project — JavaScript, 2025-12, 1 fork; arjunji123 — language not listed, 2025-07; Job-Portal---Task — JavaScript, 2025-04; UnitradeBot_AWS — JavaScript, 2025-02; stake-demo — JavaScript, 2025-02; Aignite — TypeScript, 2025-01; Wanderlust — JavaScript, 2024-08; Attirista — JavaScript, 2024-08; Invoice-Generator — JavaScript, 2024-07; Shophub — JavaScript, 2024-03; Sudoku-Solver — JavaScript, 2023-06.
My hire-my-idea-assignment repository is a JavaScript project on GitHub under @arjunji123. It started in 2026-03 and was last updated in 2026-03. Its README identifies it as a React + Vite template: a minimal setup for getting React working in Vite with HMR and some ESLint rules. The captured README does not describe what the assignment or application does beyond this template setup.
The README lists two official Vite React plugins: @vitejs/plugin-react, which uses Oxc, and @vitejs/plugin-react-swc, which uses SWC. It leaves the React Compiler disabled because of its impact on development and build performance, and links to React’s installation documentation for adding it.
For production applications, the README recommends TypeScript with type-aware lint rules enabled. It points to Vite’s TypeScript React template and typescript-eslint for integration guidance.
My luca-voice-agent repository is a JavaScript project on GitHub under @arjunji123. I started it in 2025-12 and last updated it in 2026-01. Its README describes a minimal Node.js voice agent that connects to browser or Google Meet calls and responds to speech.
The documented voice flow transcribes speech with Assembly AI, generates AI responses with OpenRouter, synthesizes speech with Murf.ai, and sends the audio to the meeting. Listed features include real-time speech-to-text, natural AI conversations, high-quality voice output, browser and Google Meet support, automatic silence detection, and avoiding duplicate responses. The README says to configure ASSEMBLY_AI_KEY for speech-to-text, OPENROUTER_API_KEY for AI responses, MURF_AI_KEY for text-to-speech, and ATTENDEE_API_KEY for meeting integration.
npm install
# Configure the API keys in .env
node index.js
# Test locally at http://localhost:5005
# To use Google Meet:
ngrok http 5005
# Use the ngrok URL in the web form and submit to join the meeting.
The README identifies index.js as the customization point: greeting is at line 210 (agentConfig.greeting), prompt at line 208 (agentConfig.prompt), voice at line 211 (agentConfig.model), and response size at line 30 (MAX_TOKENS: 300). The listed voice examples are en-US-alina and en-US-cooper. The README does not provide API-key values or deployment instructions beyond the ngrok workflow.
My Subhdin_be repository is a TypeScript project on GitHub under @arjunji123. It started in 2026-06 and was last updated in 2026-08. Its README calls it “Subhdin Backend (Milestone 1)” and describes a professional Node.js + TypeScript backend for the Vendor Module.
- The documented stack is Node.js, Express, TypeScript, Prisma, PostgreSQL, Zod validation through a shared package, and JWT authentication.
For local database setup, I need a Supabase project and two connection URLs: the transaction pooler URL on port 6543 for DATABASE_URL, and the direct connection URL on port 5432 for DIRECT_URL. The README specifies pgbouncer=true, connection_limit=1, and sslmode=require for DATABASE_URL, and sslmode=require for DIRECT_URL. It says to update .env from .env.example, keep the database password and project ref secure, and not commit .env.
npm install
cp .env.example .env
npm run prisma:generate -w apps/api
npm run prisma:migrate -w apps/api
npm run dev:api
curl http://localhost:4000/api/health
The README also lists npm run lint:api, npm run test:api, npm run build:api, and npm run start:api. The health-check URL is http://localhost:4000/api/health. The README gives setup instructions but reports no execution, test, or migration results; it also does not specify the actual Supabase project or environment values, API endpoints beyond the health check, Vendor Module functionality, or a deployment target.
- The repository structure places the backend API in
apps/apiand shared Zod contracts inpackages/shared.
I designed the requirements around what each document belongs to: one Form 1040 per return, but one government ID per signer. A waiver means an expected document will not arrive; a removal means it should never have been expected. Removals therefore remain in force even when the derivation rules continue to expect the item, with that disagreement shown to the accountant.
I preserve human decisions across derivations, including setting aside a document, filing it manually, and unfiling it. System-generated parking is different: it is reconsidered when household facts change. When an unexpected W-2 arrives, I record the employment fact and re-derive the requirements instead of adding a one-off checklist item; this keeps the facts and requirements aligned and lets the new derivation file the document.
Automatic filing uses an 85% threshold in AUTO_MATCH_CONFIDENCE, and the screen shows the threshold to the accountant. The example confidence for reading every field from a form is 97%, while guessing from a filename is 66%, so the phone-photo ID guess needs human confirmation. Closed requirements stay visible to matching, allowing the tool to explain that a document was already received or marked not needed instead of reporting that nothing expects it.
The domain layer is pure logic without database or web-framework dependencies: it defines value types and normalization, derives expected documents from facts, matches arriving documents or requests human review, and reconciles a fresh derivation with an accountant-marked list. The services layer applies that logic to database rows, runs and logs derivations, handles intake and accountant actions, re-checks the queue when facts change, and provides the screen's view model. extraction.py reads documents; models.py defines the schema; web.py contains routes; and cli.py supports seeding and status checks without a browser. Requirement keys use normalized employer names, and a unique constraint bounds concurrency damage but does not prevent races or provide optimistic locking.
The test suite covers rules (12 tests), reconciliation over time (10), matching (31), real-file intake (27), the database-backed workflow (27), and web screens and actions (21), for 128 tests total. The sample-document directory contains real IRS forms and twelve files built from them. The prototype has one firm and one accountant identified as accountant in the audit trail, with no login or multi-tenancy. It also lacks OCR, client reminders or a portal, household editing, and migrations; images without a text layer fall back to filename-based reading with low confidence, and a production deployment would need OCR and Alembic migrations. Only 1040, W-2, and government ID are derived; other types can be added as manual other items.
My next design improvements are to key employer identity on EIN when available and fall back to a name slug, because name normalization can both split one employer into multiple slots and merge distinct employers. I also want anonymous W-2 slots such as slot-1 and slot-2 for jobs whose employers are not yet known; supporting their later renaming requires a reconciler rekey operation, which it does not currently have. The weighted-evidence confidence score is invented, so I would replace it with per-field extraction confidences calibrated against observed errors. Other proposed work includes a board banner showing changes since the accountant last looked, client-chasing messages based on outstanding items, and property-based reconciler tests for the invariant that repeated derivations never lose an accountant decision.
My tax-document-collection-assignment repository is a Python 3.12 and SQLite demo of a tax-accountant document-collection screen: it shows what has arrived, what remains outstanding, and what needs attention. Its central design idea is to derive the checklist from known facts more than once, while preserving the accountant’s work between derivations.
The demo uses the Okonkwo–Vance household, filing jointly for tax year 2025: Adaeze is the taxpayer, Marcus is her spouse, and Tobenna is their 17-year-old dependent. The seeded engagement is in early March, after the accountant has worked from the list for two months. It includes a received prior-year 1040, Adaeze’s ID, and two W-2s; outstanding items include Marcus’s ID and a hand-added Form 1095-A. Adaeze’s Kestrel W-2 is marked not needed because the work is a 1099 contract, while her mistakenly listed Sable Freight W-2 is removed. Eight documents need attention.
I designed the list to be re-derived from household and employment facts rather than patched with one-off checklist entries. In the demo, recording that Marcus left Harbor Point on 13 June 2025 and started at Vireo Robotics on 30 June 2025 adds Vireo’s W-2 requirement and files the unexpected W-2 that had been waiting since February. Harbor Point’s W-2 remains listed and filed because a job that ended during the year still owes a W-2. The accountant’s earlier waiver, deletion, and hand-added 1095-A remain intact. An unexpected W-2 stays in the queue until the related job is recorded; the demo also shows recording Tobenna’s previously unknown Lakeside Pool Company summer job to re-derive the list.
The demo illustrates cautious document handling: a filename-only guess for Marcus’s phone-photo ID scores 66% and is offered for one-click confirmation rather than filed automatically. A driver’s-license upload matches his outstanding ID at 97%. The reading tool does not recognize Form 1095-A, so that upload is left for manual filing against the accountant’s hand-added checklist item. Other awkward examples include an outdated 2023 W-2, a mistakenly downloaded blank current-year 1040, a W-2 for the client’s brother, a duplicate, and a damaged scan. The History view shows each derivation, its changes, and a flat audit trail.
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -m app.cli seed
uvicorn app.web:app --reload
pytest
python -m app.cli status
The seed creates the demo client and six weeks of post. It is idempotent but deletes every client in the local database and their stored files before rebuilding the demo, so it is suitable only for this single-client setup, not a multi-client system. The project uses SQLite, requires no separate database service, and has 128 tests that take about 20 seconds to run. Two sample uploads are held outside the seed in sample_documents/to_upload/.
I built the tax-document demo around three pure functions in app/domain/rules.py, app/domain/reconcile.py, and app/domain/matching.py; none imports the database or web framework, so I can test the domain logic directly. Derivation turns household facts into expected documents: each client needs last year’s completed 1040, each return signer needs a government ID, and each person needs a W-2 for each employer whose job overlapped the tax year. A job that ended in June still counts, so changing jobs then creates two W-2 slots without a special case; a job from last year with no end date is assumed to continue. Stable keys use a person’s permanent handle and a normalized employer slug, rather than names or employer spelling, and each requirement carries a plain-English rationale for the screen. For example, a job held in 2024 with no reported end date leads to an expected 2025 W-2.
Reconciliation merges each fresh derivation into existing requirements by stable key. It retires requirements that are no longer expected instead of deleting them; it updates derived fields (label, rationale, and is_active) without overwriting accountant decisions such as waivers, removals, or filed documents. An accountant-removed item stays off the list even if the rules still expect it, because the removal represents a judgment about reality; the screen explains that choice. Retirement is flagged if a document is already attached, and manual items are left alone because the rules have no opinion about them. These choices preserve the accountant’s work while keeping requirements traceable to the underlying household facts.
I only file an incoming document automatically when it is readable, typed with at least 85% confidence, associated with a recognized person and the right tax year, matches exactly one open requirement, and is not a duplicate. Otherwise, I send it to the accountant with a reason and a shortlist. The reasons cover unreadable scans, unknown or ambiguous people, wrong or missing tax years, no matching requirement, ambiguous matches, duplicates, closed requirements, and low confidence. Multi-word names must match at both ends: surname-only matching once filed Chidi Okonkwo W2.pdf against Adaeze, so a test now guards against that error. A bare surname is accepted only if it identifies one person; “Okonkwo” is ambiguous in this household.
The replaceable reader in app/extraction.py is a real parser rather than a fixture table. It extracts layout-preserving PDF text, uses printed IRS labels such as “c Employer's name, address, and ZIP code” to locate values, and falls back to the filename when the document has no text. Its confidence score sums named evidence that the review screen can show: one example reads tax year 2025, Marcus J Vance, and Vireo Robotics, Inc., for 97%. The reader can be confidently wrong about a blank form and has little useful to say about a photograph, so downstream matching treats its output as a guess with attached confidence. I can replace it by implementing the DocumentReader protocol.
The model keeps client facts (employments) separate from derived requirements, and represents derived state and accountant state in separate columns of the same requirement. It records derivation runs and their changes, links requirements to documents and extractions, and keeps a flat activity log. Removals and waivers are timestamps; unfiling deactivates a document link rather than deleting it; and extractions are appended so a newer reader does not erase an earlier result. The committed sample set has 12 files in sample_documents/inbox/ and two in sample_documents/to_upload/; the PDFs are built from genuine blank IRS forms downloaded from irs.gov using build_documents.py. The government ID is a fictional specimen marked “SPECIMEN — NOT A REAL ID”.
My Subhdin repository is a TypeScript project on GitHub under @arjunji123. It started in 2026-06 and was last updated in 2026-08. Its README describes ShaadiHub – Milestone 1 Delivery, a vendor module for an event and wedding services marketplace. Milestone 1 covers vendor OTP authentication, profile setup and account management, services and offers CRUD, dashboard analytics, a PostgreSQL schema using Prisma, a Cloudinary signed-upload hook, and a React Native (Expo) vendor app UI.
- The monorepo is organized into
apps/apifor the Node.js, Express, and Prisma backend;apps/mobilefor the React Native (Expo) vendor app; andpackages/sharedfor shared Zod schemas and TypeScript contracts. Supporting documentation includesdocs/standards.mdfor coding and architecture standards anddocs/milestone-1-backend.mdfor database, migrations, and APIs.
The documented API base URL is http://localhost:4000/api. The README lists two OTP endpoints, POST /api/auth/request-otp and POST /api/auth/verify-otp; the current OTP provider mode is mock, and the request endpoint returns a debugCode to use for verification. Protected vendor routes require Authorization: Bearer <token>. The listed protected routes cover vendor profile management (GET, PUT, and DELETE /api/vendor/me), service and offer CRUD, the vendor dashboard, analytics events, and upload signatures.
Cloudinary upload signatures are implemented for secure client-side media uploads. The README says Twilio or MSG91 OTP integration can be plugged into apps/api/src/modules/auth/auth.service.ts; it does not establish that either provider has been integrated. The documented deployment targets are Render, Railway, and AWS.
cd /Users/apple/Desktop/Personal/Subhdin
npm install
docker compose up -d
cp .env.example .env
npm run prisma:generate -w apps/api
npm run prisma:migrate -w apps/api
npm run dev:api
npm run start -w apps/mobile
npm run test:api
The README's local workflow installs dependencies from the repository root, starts PostgreSQL with Docker Compose, copies the example environment file, generates the Prisma client, runs migrations, and starts the API. It starts the mobile app separately and uses the Expo QR code for Android or iOS. It also lists npm run test:api as the API test command, but provides no test-pass, coverage, performance, or deployment results. The README labels the repository “Milestone 1 Delivery” but does not clarify whether the milestone is complete or provide deployment instructions.
My FreshBhoj---App repository is on GitHub under @arjunji123. Its metadata labels it Kotlin, says it started in 2026-02, and lists 2026-10 as its last update. The README names the project FreshBhoj and documents a React Native-style app structure and workflow; it does not explain the difference between that description and the Kotlin label.
The README organizes the app by responsibility and business feature. Under src/app/, App.tsx is the entry point, navigation/ holds root Stacks and Tabs, and theme/ contains colors, typography, and spacing. Shared UI lives in src/components/, with Button and Typography examples. Feature-specific code lives in src/features/: auth/ includes screens, components, hooks, and authStore.ts, while dashboard/ shows a screens directory and an ellipsis placeholder.
- The README also places global hooks such as
useThemeanduseOnlineStatusinsrc/hooks/; API configuration and external-service wrappers such asapi.tsandstorage.tsinsrc/services/; date-formatting and validation helpers insrc/utils/; and images, fonts, and SVGs insrc/assets/.
To work with the project, the README lists Node.js and npm as prerequisites, plus the Android SDK for Android development or Xcode for iOS development. It instructs me to install dependencies and run the app with React Native CLI:
npm install
npx react-native run-android
npx react-native run-ios
The README describes a feature-oriented organization, grouping code by business logic, but gives no further rationale. It does not establish whether the app is implemented in Kotlin, React Native, or a combination. It also leaves the contents of the dashboard feature beyond screens/ unspecified, and gives no app behavior, API details, build results, or test results.
My Portfolio repository is a TypeScript project on GitHub. It started in 2024-06 and was last updated in 2026-10. Its README links to a walkthrough video: https://youtu.be/sUKptmUVIBM.
- The README presents the project as a learning resource covering Latest Next.js 13 features, the Next.js App Router and Server Actions, Client and Server Components, beginner and intermediate TypeScript, Tailwind CSS, Context API, Framer Motion animations, React.Email and Resend, custom React hooks, modern UI design, light and dark mode, and responsive websites.
I recommend learning JavaScript and CSS fundamentals well before pursuing professional development, and point learners to my Professional JavaScript and Professional CSS courses. The README also says my complete React and Next.js course is close to release and invites readers to join the email list for early-bird pricing; it does not give a release date.
Add RESEND_API_KEY as an environment variable in .env.local. In the send-email.ts action file, change the "to" email to your own email.
My Freshbhoj-website repository is a TypeScript project on GitHub, started in 2026-03 and last updated in 2026-11. Its README describes a Next.js project bootstrapped with create-next-app. I can edit the page in app/page.tsx, and the page auto-updates as I edit it. The project uses next/font to automatically optimize and load Geist, described as a new font family for Vercel.
npm run dev
yarn dev
pnpm dev
bun dev
# Then open http://localhost:3000 in a browser.
- The README points to the Next.js documentation, an interactive Learn Next.js tutorial, the Next.js GitHub repository, and Vercel deployment documentation. It presents the Vercel Platform as the easiest way to deploy the app. The README does not specify the app’s features, target users, dependencies beyond the Next.js setup, or deployment status.