Full Stack Development Intern (MERN + React Native)
Location: Remote
Stipend: INR 7 – 15K
About Daynt
At Daynt, we specialize in providing cutting-edge technology solutions to help businesses
and visionary founders reach their full potential. As a Tech Team as a Service provider, we
offer a cross-functional team of experts dedicated to delivering innovative solutions in
mobile app development, web software, cybersecurity, and tech architecture planning.
Join us at Daynt and be part of a dynamic team driving innovation, digital transformation,
and business growth through technology!
Internship Responsibilities
• Assist in the full software development lifecycle (SDLC), contributing to development,
unit testing, and deployment under the guidance of senior developers.
• Support in designing and developing responsive full-stack web applications using
modern frameworks and methodologies.
• Collaborate on building and maintaining cross-platform mobile applications using
React Native, ensuring smooth performance and usability.
• Write clean, modular, and well-documented code while learning best practices in
modern web and mobile development.
• Assist in deploying web applications in cloud environments such as Azure or AWS and
gain exposure to managing scalable production environments.
• Participate in troubleshooting and debugging sessions to help maintain and enhance
existing systems.
• Engage in daily or weekly team meetings, provide progress updates, and collaborate
with mentors and team members to achieve project goals.
Internship Requirements
• Basic understanding of full-stack development using the MERN stack (MongoDB,
Express, React, [Link]).
• Familiarity with frontend development tools such as [Link], Material UI, Redux, and
React Hook Form is preferred.
• Interest or basic experience in mobile app development using React Native.
• Familiarity with both SQL-based (e.g., MySQL, PostgreSQL) and document-based
databases (e.g., MongoDB) will be a plus.
• Understanding of three-tier architecture (frontend, backend, and database) and how
these layers interact.
• Basic knowledge of Git and GitHub for version control and collaboration.
• Eagerness to learn, strong problem-solving mindset, and ability to work
collaboratively in a remote-first environment.
Perks
• Mentorship from experienced developers and exposure to real-world projects.
• Flexible work environment.
• Opportunity to gain hands-on experience in both web and mobile technologies.
• Certificate of Internship and reference letter upon successful completion.
• Pre-placement offer based on performance during the course of the internship.
Assignment (Pick One) — GitHub Submission Only
Choose any one of the challenges below and implement it using [Link] + shadcn/ui.
Your submission must be a public GitHub repository with a clear, self-contained
[Link] that lets an assessor run the project end-to-end by following your
instructions—no back-and-forth required.
You may make reasonable assumptions where specs are ambiguous; state every
assumption explicitly in the README.
Strict rule: Only GitHub repo links with a well-defined README will be accepted. All
other formats (Drive/Zip/Deployed-only/Figma-only/etc.) will be disqualified.
Submission deadline: 17 October (23:59, IST)
Submission URL: [Link]
Who should submit: Interested students must pick exactly one challenge and submit
a GitHub link.
Technical Expectations
• Stack: [Link] (App Router), TypeScript, Tailwind CSS, shadcn/ui.
• Data layer: Keep it simple (e.g., in-memory, file-based JSON, or SQLite/Prisma).
If you require env vars, include a .[Link] and seed script or instructions.
• Auth (when needed): Credentials flow is fine (e.g., email + password). Provide
test credentials in the README.
• DX & Access: npm i / npm run dev should be enough after following the
README.
• README must include: prerequisites, setup, env vars, seed data, run
commands, test creds, assumptions, features, known limitations, and how to
verify each acceptance criterion.
• Quality: Clean component structure, basic accessibility (focus, labels, sensible
contrast), and consistent spacing/typography (8-pt grid).
Challenges (choose one)
Challenge 1: Dynamic Form Builder Portal
Problem Statement
Create a comprehensive form builder portal where authenticated users can design
custom forms with various field types, generate shareable public links, and view all
submissions in a centralized dashboard.
Requirements
Authentication System
• Implement user registration and login functionality
• Secure authentication using JWT tokens
• Session management for logged-in users
Form Creation Interface
Users should be able to create forms with the following field types:
• Text Box: Single-line text input
• Numeric Box: Number-only input with validation
• Multiline Box: Textarea for longer text responses
• Checkbox Groups: Multiple selection options
• Radio Groups: Single selection from multiple options
• Image Upload: File upload with image preview
Form Management
• Create, edit, and delete forms
• Each form should have:
o Title and description
o Configurable fields with labels
o Field validation rules
o Public/private status toggle
• Generate unique public URLs for each form (e.g., /form/[unique-id])
• Copy-to-clipboard functionality for sharing links
Response Management
• Public form submission page (no authentication required)
• Store all submissions with timestamp
• Dashboard view showing:
o List of all created forms
o Number of responses per form
o Detailed view of individual responses
o Export responses to CSV/JSON
Default Demo Content
Create 3 pre-populated forms demonstrating all features:
1. Customer Feedback Form: Text boxes, radio groups, multiline box
2. Job Application Form: Text boxes, file upload, checkbox groups
3. Survey Form: All field types showcased
Technical Specifications
• Frontend: [Link] (App Router or Pages Router)
• Backend: NestJS with RESTful APIs
• Database: PostgreSQL or MongoDB
• File Storage: Local storage or cloud service (S3/Cloudinary)
• Authentication: JWT with httpOnly cookies
• UI Requirements:
o Modern, responsive design (mobile-first)
o Loading states and skeleton screens
o Toast notifications for all actions
o Form validation with error messages
o Drag-and-drop form builder (bonus)
Error Handling
• Comprehensive error handling on both frontend and backend
• User-friendly error messages via toast notifications
• Validation errors displayed inline on forms
• 404 pages for invalid form links
• Rate limiting on submission endpoints
Deliverables
1. Complete source code on GitHub (separate repos or monorepo)
2. [Link] with:
o Project description
o Technology stack
o Prerequisites ([Link] version, etc.)
o Installation instructions
o Environment variables setup
o Database setup and migration commands
o Commands to run frontend and backend locally
o Default login credentials
o API documentation or Swagger link
3. SQL/NoSQL schema/models
4. Environment variable templates (.[Link])
Challenge 2: Doctor Appointment Booking System
Problem Statement
Build a two-portal system: one for doctors to manage their availability and another for
patients to book appointments, with intelligent scheduling and anti-abuse
mechanisms.
Requirements
Doctor Portal
• Doctor authentication (registration/login)
• Availability management:
o Set working hours (start time and end time)
o Define working days (Monday-Friday)
o 20-minute timeslot intervals
o View upcoming appointments
o Mark slots as unavailable (breaks, emergencies)
• Dashboard showing:
o Today's appointments
o Weekly schedule overview
o Patient details for each appointment
Public Booking Portal
• No authentication required for patients
• Features:
o Search/filter doctors by name or specialty
o View available timeslots for next 7-14 days
o "Any Available Doctor" option that:
Shows all available slots across all doctors
Automatically assigns the available doctor upon booking
o Book appointments with patient information:
Name, email, phone number
Reason for visit (optional)
o CAPTCHA verification before booking confirmation
o Email/SMS confirmation (mock or real implementation)
Scheduling Logic
• Prevent double-booking of timeslots
• Handle overlapping doctor schedules efficiently
• Show real-time availability updates
• Block past dates and times
• Weekend blocking (Saturday-Sunday)
CAPTCHA Integration
• Implement CAPTCHA (Google reCAPTCHA v2/v3 or custom solution)
• Validate CAPTCHA on backend before confirming bookings
• Rate limiting per IP address
Default Demo Content
Create 3 doctors with pre-configured schedules:
1. Dr. Sarah Johnson (General Physician)
o Monday-Friday: 9:00 AM - 5:00 PM
2. Dr. Michael Chen (Cardiologist)
o Monday-Friday: 10:00 AM - 6:00 PM
3. Dr. Emily Rodriguez (Pediatrician)
o Monday, Wednesday, Friday: 8:00 AM - 4:00 PM
o Tuesday, Thursday: 1:00 PM - 7:00 PM
Note: Ensure Dr. Johnson and Dr. Chen have overlapping hours (10 AM - 5 PM) to
demonstrate the "Any Available Doctor" feature.
Technical Specifications
• Frontend: [Link] with Server-Side Rendering for public pages
• Backend: NestJS with WebSocket for real-time updates (optional)
• Database: PostgreSQL with proper indexing for timeslot queries
• CAPTCHA: Google reCAPTCHA or hCaptcha
• UI Requirements:
o Calendar/timeline view for appointments
o Color-coded availability indicators
o Responsive design for mobile booking
o Toast notifications for booking confirmations
o Loading states during availability checks
Error Handling
• Handle concurrent booking attempts gracefully
• Validate all input fields with meaningful error messages
• CAPTCHA failure handling with retry mechanism
• Network error handling with retry logic
• Time zone considerations (bonus)
Deliverables
1. Complete source code on GitHub
2. [Link] with:
o Project overview
o Setup instructions
o Database schema and migrations
o Environment variables (including CAPTCHA keys)
o How to run both frontend and backend
o Default doctor credentials
o Testing instructions
o API documentation
3. Database migration scripts
4. Environment variable templates (.[Link])
Challenge 3: Offline-First Note Taking Application
Problem Statement
Develop a robust note-taking application that works seamlessly both online and offline,
with automatic synchronization, instant autosave, and multi-device support.
Requirements
Core Features
• User authentication (registration/login)
• Create, edit, delete notes
• Each note contains:
o Title
o Content (rich text editor recommended)
o Timestamps (created, last modified)
o Sync status indicator
Offline Functionality
• Full functionality without internet connection
• Use browser storage (IndexedDB) for offline persistence
• Queue changes made while offline
• Automatic synchronization when connection is restored
Auto-Save Mechanism
• Save changes instantly as user types (debounced)
• No manual "Save" button required
• Character-level change detection
• Optimistic UI updates
Sync System
• Background sync when online
• Conflict resolution strategy (last-write-wins or user choice)
• Retry failed syncs automatically
Connection Indicator
• Visual indicator showing:
o Online (green icon/badge)
o Offline (red/orange icon/badge)
o Syncing (loading spinner)
• Status changes with smooth transitions
• Toast notifications on connection change
Multi-Device Support
• Notes saved in backend database
• Sync across devices when user logs in
• Real-time updates across open sessions (WebSocket - bonus)
Default Demo Content
Create 2 pre-populated notes for new users:
1. Welcome Note:
o Title: "Welcome to Your Notes"
o Content: Guide on how to use the app
2. Feature Demo:
o Title: "Try Me Offline!"
o Content: Instructions to test offline functionality
Technical Specifications
• Frontend: [Link] with PWA capabilities
• Backend: NestJS with RESTful APIs
• Database: PostgreSQL or MongoDB for cloud storage
• Offline Storage: IndexedDB (via [Link] or similar)
• Sync Strategy:
o Debounced autosave (500ms-1s delay)
o Queue-based sync mechanism
o Background Sync API (bonus)
• UI Requirements:
o Clean, distraction-free writing interface
o Sidebar with notes list
o Search and filter functionality
o Rich text editor (Quill, TipTap, or Slate)
o Responsive design
o Dark mode toggle (bonus)
Connection Handling
• Detect online/offline status using [Link]
• Listen to online/offline events
• Implement exponential backoff for retry logic
• Visual feedback for all sync states:
o Saved locally (offline)
o Syncing to server
o Saved to cloud
o Sync failed (with retry option)
Error Handling
• Handle sync conflicts gracefully
• Show user-friendly errors via toasts
• Persist error states for investigation
• Provide manual sync trigger option
• Data loss prevention mechanisms
Deliverables
1. Complete source code on GitHub
2. [Link] with:
o Project description and architecture
o Technology stack details
o Installation and setup guide
o Environment configuration
o Database setup
o How to run locally
o How to test offline functionality
o PWA installation instructions (if implemented)
o Sync mechanism explanation
o API documentation
3. Database schema and migrations
4. Environment variable templates (.[Link])
General Guidelines for All Projects
Code Quality
• Follow TypeScript best practices
• Implement proper error boundaries
• Write clean, maintainable code
• Use ESLint and Prettier
• Add comments for complex logic
Security
• Sanitize all user inputs
• Implement proper CORS policies
• Use environment variables for secrets
• Hash passwords (bcrypt)
• Protect against SQL injection/NoSQL injection
• Rate limiting on sensitive endpoints
Performance
• Optimize database queries
• Implement pagination where needed
• Use lazy loading for images
• Code splitting in [Link]
• Cache strategies for API responses
Testing (Bonus)
• Unit tests for critical functions
• Integration tests for API endpoints
• E2E tests for user flows
Documentation
• Clear README with setup instructions
• API documentation (Swagger/Postman)
• Code comments where necessary
• Architecture diagrams (bonus)
GitHub Repository Structure
project-name/
├── frontend/ # [Link] application
├── backend/ # NestJS application
├── [Link] # Main project README
├── .gitignore
└── [Link] # Optional containerization
What to Include in Your README (mandatory)
1. Project overview (which challenge, what you built).
2. Assumptions (every non-obvious decision).
3. Prerequisites (Node version, any local DB, tools).
4. Setup
o Install: npm install
o Env: .[Link] → .env (explain keys)
o Seed: how to create initial users/data (if applicable)
5. Run & verify
o Commands: npm run dev (+ any build/migrate steps)
o Test credentials and step-by-step to validate each acceptance item
6. Features & limitations
o What works, known gaps, future improvements
7. Notes on architecture
o Folder structure, key components, state/data approach
8. Accessibility & UI
o How you handled focus/labels/contrast and spacing/typography
Evaluation Rubric (100 pts)
• Functionality & Acceptance Criteria (35%) — Does it meet the spec reliably?
• Code Quality & Structure (20%) — Readability, components, state/data flow.
• UX & UI Craft (20%) — Clarity, consistency, accessibility basics.
• README & Dev Experience (15%) — Can we run/verify without guessing?
• Polish & Edge Cases (10%) — Empty/error/loading states, validation.
Disqualification & Notes
• Only public GitHub repository links with a complete README will be
evaluated.
• Submissions via other means (Drive/Zip/links without code/deployed-only) will
be rejected without review.
• Do not commit real secrets; use. [Link].
• Original work only. Plagiarism or spam submissions will be disqualified.