Skip to content

Full-Stack Engineer

Full-Stack Engineer

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.
Honesty upgrade

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.
Reality snapshot

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.
Work samples

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.

Proof links: Pokédex case study, GitHub

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.

Proof links: Car-Match case study, GitHub

Toolbox

What’s in rotation (and how confident I am)

React + Gatsby (comfortable)Vanilla JS + HTML/CSS (comfortable)Next.js (learning)Node.js + Express (learning)FastAPI (exploring)Netlify + GitHub Pages deploys (comfortable)Docker Compose for dev parity (learning)Playwright / Vitest (exploring)

Each repository documents which components are stable and which are experimental to indicate maturity.

Growth plan

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

ToolCategoryMy Maturity LevelOfficial Docs
ReactFrontend libraryComfortableReact
GatsbyStatic site generatorComfortableGatsby
Next.jsReact frameworkLearningNext.js
Vanilla JS + HTML/CSSCore webComfortableMDN
Node.js + ExpressBackend frameworkLearningExpress
FastAPIPython backendExploringFastAPI
MongoDB / MongooseDatabaseLearningMongoose
NetlifyFrontend deploymentComfortableNetlify
GitHub PagesStatic hostingComfortableGitHub Pages
Docker ComposeDev environment parityLearningDocker Compose
VitestUnit testingExploringVitest
PlaywrightE2E testingExploringPlaywright

Role Comparison: Full-Stack Engineer vs. Adjacent Roles

DimensionFull-Stack EngineerBackend EngineerFrontend EngineerDevOps Engineer
Primary focusFrontend + backend togetherServer logic, APIs, databasesUI, UX, client-side logicCI/CD, deployment pipelines
Core languagesJavaScript, TypeScriptJavaScript, Python, GoJavaScript, TypeScriptBash, YAML, Python
Frontend depthHigh — builds UINoneVery high — specializesNone
Backend depthMedium — builds APIsVery high — specializesNoneLow
Database workMedium — connects UI to DBHigh — schema designLowLow
DeploymentMedium — deploys full appsLow — deploys APIsMedium — deploys UIsHigh — builds pipelines
Typical deliverableDeployed full-stack appDeployed API serviceDeployed frontend appWorking CI/CD pipeline
My current levelCar-Match, this siteSmall deployed APIsPokédex, AnimalSoundsPersonal CI scripts

Expanded Process Notes

How I approach building a full-stack application

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Add CI checks — GitHub Actions runs linting, type-checking, and build validation before any deploy. Build failures block the deployment.
  6. 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