Full-stack practice focused on putting both sides together
I pair React frontends with small backend services to practice full-stack workflows. The difference between this page and my backend page is scope: backend is about the API itself, while this page is about getting the frontend and backend working together as one experience.- Public UI work: this site, the Pokédex, and other live front-end projects.
- Integrated project: Car-Match combines frontend flows with a deployed Express backend.
- Shipping focus: deploys, CI checks, and documented limitations across the stack.
Clear scope, upfront
What I have
- Public front-end deployments accessible via live URLs.
- Small backend services paired with these demos.
- Documentation that identifies missing features and known risks.
What I am still working toward
- Ownership of production full-stack systems or large-scale traffic environments.
- Cross-team delivery and real stakeholder timelines.
- Deep testing discipline across the stack.
What I’m doing next
- Strengthen authentication and session management workflows.
- Improve test coverage and CI reliability.
- Practice accessibility reviews with peers.
What I actually ship
Front-end demos (public)
The frontend side is where I ship the most often, but the full-stack part matters when the UI is tied to real data and backend behavior.
- React and Gatsby UI development for this site and the Interactive Pokédex.
- GitHub Pages deployments for AnimalSounds and other demonstration projects.
- CI scripts perform linting and build validation before deployment.
Back-end pairings (small-scale)
This is what makes the page different from the frontend-only work: wiring the interface to auth, persistence, and backend flows.
- Car-Match backend is deployed on Render with MongoDB Atlas.
- Free-tier cold starts can take several minutes; this limitation is documented in the README.
- Copilot and ChatGPT are used to scaffold routes before manual review.
Evidence of progress
Interactive Pokédex
Focus: frontend-heavy project that demonstrates data fetching, search, and deployment, not a backend-heavy system.
- Next.js static export with client-side filtering for the original 151 Pokémon.
- Repository includes prompt logs and TODOs for pagination, offline mode, and testing.
Car-Match
Focus: the clearest full-stack example on this site because the frontend and backend have to work together for auth, matching, forums, and messaging.
- React frontend + Express backend with MongoDB persistence.
- Deployments and known limitations are documented in the README.
What’s in rotation (and how confident I am)
Each repository documents which components are stable and which are experimental to indicate maturity.
What I still need
- Building auth and session flows for deployed demos.
- Accessibility reviews led by experienced UX/FE engineers.
- Deeper testing discipline (unit, integration, and visual regression).
- Mentorship on prioritizing work across the stack with real stakeholders.
If your team provides mentorship and pair-programming support in these areas, I am open to discussing opportunities.
Core Responsibilities
A Full-Stack Engineer is responsible for building and maintaining both the frontend user interface and the backend services that power it. Key responsibilities include:
- Frontend development: Building responsive, accessible UIs with React and Gatsby for static site generation, or Next.js for server-rendered applications (Source).
- Backend API development: Building RESTful endpoints with Express.js or FastAPI that serve data to the frontend.
- Database integration: Connecting the frontend to databases like MongoDB via backend APIs, managing data flow from UI to persistence layer.
- Authentication flows: Implementing end-to-end auth — login, registration, session management, and protected routes — using JWT tokens.
- Deployment: Deploying both frontend and backend to platforms like Netlify, GitHub Pages, or Render with CI checks that validate builds.
- Testing: Writing unit, integration, and end-to-end tests with Vitest and Playwright to validate behavior across the stack.
- Accessibility: Ensuring UIs meet WCAG accessibility standards with semantic HTML, ARIA labels, and keyboard navigation.
Key Skills
- Frontend frameworks: React (Source), Gatsby (Source), Next.js (Source)
- Languages: JavaScript, TypeScript (Source), HTML/CSS (Source)
- Backend frameworks: Express.js (Source), FastAPI (Source)
- Databases: MongoDB / Mongoose (Source)
- Authentication: JWT (Source), session management
- Testing: Vitest (Source), Playwright (Source)
- Deployment: Netlify (Source), GitHub Pages (Source), Render (Source)
- Containers: Docker Compose (Source) for dev environment parity
- Accessibility: WCAG 2.1 (Source), Lighthouse audits (Source)
Tools and Technologies
| Tool | Category | My Maturity Level | Official Docs |
|---|---|---|---|
| React | Frontend library | Comfortable | React |
| Gatsby | Static site generator | Comfortable | Gatsby |
| Next.js | React framework | Learning | Next.js |
| Vanilla JS + HTML/CSS | Core web | Comfortable | MDN |
| Node.js + Express | Backend framework | Learning | Express |
| FastAPI | Python backend | Exploring | FastAPI |
| MongoDB / Mongoose | Database | Learning | Mongoose |
| Netlify | Frontend deployment | Comfortable | Netlify |
| GitHub Pages | Static hosting | Comfortable | GitHub Pages |
| Docker Compose | Dev environment parity | Learning | Docker Compose |
| Vitest | Unit testing | Exploring | Vitest |
| Playwright | E2E testing | Exploring | Playwright |
Role Comparison: Full-Stack Engineer vs. Adjacent Roles
| Dimension | Full-Stack Engineer | Backend Engineer | Frontend Engineer | DevOps Engineer |
|---|---|---|---|---|
| Primary focus | Frontend + backend together | Server logic, APIs, databases | UI, UX, client-side logic | CI/CD, deployment pipelines |
| Core languages | JavaScript, TypeScript | JavaScript, Python, Go | JavaScript, TypeScript | Bash, YAML, Python |
| Frontend depth | High — builds UI | None | Very high — specializes | None |
| Backend depth | Medium — builds APIs | Very high — specializes | None | Low |
| Database work | Medium — connects UI to DB | High — schema design | Low | Low |
| Deployment | Medium — deploys full apps | Low — deploys APIs | Medium — deploys UIs | High — builds pipelines |
| Typical deliverable | Deployed full-stack app | Deployed API service | Deployed frontend app | Working CI/CD pipeline |
| My current level | Car-Match, this site | Small deployed APIs | Pokédex, AnimalSounds | Personal CI scripts |
Expanded Process Notes
How I approach building a full-stack application
- Design the data flow — Map out how data moves from the database through the backend API to the frontend UI. For Car-Match, this meant MongoDB documents → Express routes → React components.
- Build the backend API first — I start with Express endpoints for CRUD operations and auth, so the frontend has something to call. JWT-based auth is implemented early using the JWT standard.
- Build the frontend — I use React for component-based UIs. For content-heavy sites, Gatsby provides static site generation with excellent performance. For app-like experiences, Next.js offers server-side rendering and API routes.
- Wire them together — Connect the React frontend to the Express backend with fetch calls or API clients. Handle loading states, error states, and empty states in the UI.
- Add CI checks — GitHub Actions runs linting, type-checking, and build validation before any deploy. Build failures block the deployment.
- Deploy and document — Frontend goes to Netlify or GitHub Pages; backend goes to Render. Known limitations (cold starts, missing tests, incomplete features) are documented in the README.
Common pitfalls I have encountered
- CORS issues: When frontend and backend are on different domains, Cross-Origin Resource Sharing must be configured. The cors middleware for Express handles this, but it is easy to misconfigure.
- Free-tier cold starts: Render's free tier can take several minutes to wake the backend, which makes the full-stack app appear broken. Documenting this in the README sets correct expectations.
- Inconsistent state management: Without a clear state strategy, React components can get out of sync with the backend. Using React Query or a context-based approach helps (Source).
- Accessibility gaps: Full-stack apps often neglect accessibility. Running Lighthouse audits and testing with keyboard navigation catches common issues.
References
- React Documentation
- Gatsby Documentation
- Next.js Documentation
- Express.js Documentation
- FastAPI Documentation
- MongoDB Documentation
- Mongoose Documentation
- JWT Introduction
- Netlify Documentation
- GitHub Pages Documentation
- Render Documentation
- Docker Compose Documentation
- Vitest Documentation
- Playwright Documentation
- TypeScript Documentation
- MDN Web Docs — HTML
- WCAG 2.1 Guidelines
- Lighthouse Documentation
- GitHub Actions Documentation
- CORS Middleware for Express
