Skip to content

Backend Engineer

Backend Engineer

Backend practice with small deployed APIs and honest limitations

I have not held a paid Backend Engineer title yet. What I can show is small-scale API work, local backend experiments, and documentation that clearly states what is missing.
  • Express API work: Car-Match deployed on Render with MongoDB Atlas and JWT auth.
  • Backend experiments: FastAPI work for Convo-AI plus smaller schema and queue reps.
  • Documentation: READMEs and issues list cold starts, missing features, and rough edges.
Honesty upgrade

Clear scope, upfront

What I have

  • Personal APIs deployed on small hosting providers for demonstration purposes.
  • Local FastAPI experiments to learn backend service patterns.
  • Documentation that lists missing features and risks.

What I am still working toward

  • Ownership of production backend systems or high-traffic services.
  • Tracing, alerting, and stronger observability beyond small-scale logs.
  • Large-scale data modeling and migrations.

What I’m doing next

  • Auth hardening (refresh tokens, auditing, device trust).
  • Schema migration practice for relational databases.
  • Async job queues and caching experiments.
Reality snapshot

Where I actually spend time

Personal deployments (public, small-scale)

This is the most concrete backend work I can point to right now: small public APIs with the tradeoffs clearly documented.

  • Node and Express APIs for Car-Match, deployed on Render with MongoDB Atlas.
  • Free-tier cold starts can take several minutes; this limitation is documented in the README.
  • README documentation lists missing features such as authentication hardening, load testing, and observability.

Local experiments (learning)

I also use smaller local experiments to learn backend patterns without pretending they are more mature than they are.

  • FastAPI experiments for Convo-AI to understand Python-based backend services.
  • AI-assisted pair programming in development sessions; prompts and edits are included in the repository for traceability.
Work samples

What I can show today

Car-Match API

Stack: Express, MongoDB Atlas, JWT, Render

Purpose: CRUD routes for matching users, forums, messaging, and auth flows.

  • Limitations: free-tier cold starts, no rate limiting, limited structured logging, and no serious load testing yet.
  • Docs: Postman collections and README tables instead of generated OpenAPI docs.

Proof links: Car-Match case study, GitHub

Secrets Management tutorial

Stack: demo frontend + documented backend/security patterns

Purpose: show secure versus insecure handling of secrets in a way beginners can inspect.

  • Limitations: educational demo only, not a production backend service.
  • Disclosure: large portions were scaffolded with ChatGPT and Copilot before manual annotation.

Proof links: EthicsFrontEndDemo repo, EthicsFrontEndDemo Live demo

Toolbox (with confidence labels)

Stacks I reach for

Node.js + Express (comfortable for prototypes)TypeScript (learning)MongoDB / Mongoose (learning)PostgreSQL basics (exploring)FastAPI (exploring)Jest + Supertest (learning)Postman collections (comfortable)

Each repository documents areas of strength and areas where AI tools or tutorials were heavily used.

Help wanted

Gaps I’m working through

  • Designing auth flows that include refresh tokens, device trust, and auditing.
  • Schema design + migrations for relational databases (beyond toy schemas).
  • Observability and tracing for Express/FastAPI services.
  • Performance profiling, caching strategies, and async job processing.

If you mentor junior backend engineers in these topics, I am open to discussing opportunities.

Core Responsibilities

A Backend Engineer is responsible for designing, building, and maintaining server-side logic, APIs, and data layers. Key responsibilities include:

  • API design and development: Building RESTful endpoints with Express.js or FastAPI that handle CRUD operations, authentication, and business logic.
  • Database management: Designing schemas, writing queries, and managing data with MongoDB (document store) or PostgreSQL (relational).
  • Authentication and authorization: Implementing JWT-based auth flows (Source), refresh tokens, and role-based access control.
  • Deployment and hosting: Deploying services to platforms like Render with environment variable management and health check endpoints.
  • Testing: Writing unit and integration tests with Jest and Supertest to validate API behavior.
  • Observability: Adding structured logging, error tracking, and request tracing to diagnose issues in deployed services.
  • Documentation: Maintaining READMEs, Postman collections, and API documentation so other developers can integrate quickly.

Key Skills

Tools and Technologies

ToolCategoryMy Maturity LevelOfficial Docs
Node.js + ExpressRuntime + frameworkComfortable for prototypesExpress
TypeScriptLanguageLearningTypeScript
MongoDB / MongooseDocument databaseLearningMongoose
PostgreSQLRelational databaseExploringPostgreSQL
FastAPIPython web frameworkExploringFastAPI
Jest + SupertestTestingLearningJest
PostmanAPI testingComfortablePostman
RenderDeploymentComfortableRender

Role Comparison: Backend Engineer vs. Adjacent Roles

DimensionBackend EngineerFull-Stack EngineerDevOps EngineerCloud Engineer
Primary focusServer logic, APIs, databasesFrontend + backend togetherCI/CD, deployment pipelinesCloud infrastructure, IaC
Core languagesJavaScript, Python, GoJavaScript, TypeScriptBash, YAML, PythonPython, Bash, HCL
Key frameworksExpress, FastAPI, DjangoReact, Express, Next.jsGitHub Actions, DockerTerraform, AWS CLI
Database workHigh — schema design, queriesMedium — consumes APIsLow — manages DB infraMedium — manages DB services
Frontend workNoneHigh — builds UINoneNone
InfrastructureLow — deploys to hostsLow — deploys full appsHigh — builds pipelinesHigh — designs cloud arch
Typical deliverableDeployed API serviceDeployed full-stack appWorking CI/CD pipelineProvisioned cloud resources
My current levelSmall deployed APIsCar-Match, this sitePersonal CI scriptsAWS internship

Expanded Process Notes

How I approach building a backend API

  1. Define the data model — Start with the entities the API needs (users, posts, messages) and their relationships. For MongoDB, this means designing document shapes; for PostgreSQL, this means designing normalized tables (Source).
  2. Choose the framework — For JavaScript projects, I reach for Express because it is minimal and well-documented. For Python projects, I use FastAPI for its automatic validation and OpenAPI generation.
  3. Implement auth early — JWT-based authentication is added before business logic so every route can be protected. The JWT standard is defined in RFC 7519 (Source).
  4. Write CRUD routes — Each resource gets create, read, update, and delete endpoints with input validation and error handling.
  5. Deploy and document limitations — I deploy to Render and document cold start behavior, missing rate limiting, and other known gaps in the README.
  6. Test with Postman and Jest — I maintain Postman collections for manual testing and write Jest + Supertest integration tests for automated validation (Source).

Common pitfalls I have encountered

  • Free-tier cold starts: Render's free tier can take several minutes to wake a sleeping service. This is documented in every project README so reviewers are not surprised.
  • No rate limiting: Without rate limiting, a deployed API is vulnerable to abuse. This is a known gap I am working to address with middleware like express-rate-limit.
  • Unstructured logging: Console.log without structured formatting makes debugging harder in production. Moving to structured JSON logging is a next step (Source).

References