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.
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.
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.
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.
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.
Stacks I reach for
Each repository documents areas of strength and areas where AI tools or tutorials were heavily used.
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
- Programming languages: JavaScript/TypeScript (Source), Python (Source)
- Web frameworks: Express.js (Source), FastAPI (Source)
- Databases: MongoDB / Mongoose (Source), PostgreSQL (Source)
- Authentication: JWT (Source), OAuth 2.0 (Source)
- Testing: Jest (Source), Supertest (Source)
- API documentation: Postman (Source), OpenAPI / Swagger (Source)
- Deployment: Render (Source), Docker (Source)
Tools and Technologies
| Tool | Category | My Maturity Level | Official Docs |
|---|---|---|---|
| Node.js + Express | Runtime + framework | Comfortable for prototypes | Express |
| TypeScript | Language | Learning | TypeScript |
| MongoDB / Mongoose | Document database | Learning | Mongoose |
| PostgreSQL | Relational database | Exploring | PostgreSQL |
| FastAPI | Python web framework | Exploring | FastAPI |
| Jest + Supertest | Testing | Learning | Jest |
| Postman | API testing | Comfortable | Postman |
| Render | Deployment | Comfortable | Render |
Role Comparison: Backend Engineer vs. Adjacent Roles
| Dimension | Backend Engineer | Full-Stack Engineer | DevOps Engineer | Cloud Engineer |
|---|---|---|---|---|
| Primary focus | Server logic, APIs, databases | Frontend + backend together | CI/CD, deployment pipelines | Cloud infrastructure, IaC |
| Core languages | JavaScript, Python, Go | JavaScript, TypeScript | Bash, YAML, Python | Python, Bash, HCL |
| Key frameworks | Express, FastAPI, Django | React, Express, Next.js | GitHub Actions, Docker | Terraform, AWS CLI |
| Database work | High — schema design, queries | Medium — consumes APIs | Low — manages DB infra | Medium — manages DB services |
| Frontend work | None | High — builds UI | None | None |
| Infrastructure | Low — deploys to hosts | Low — deploys full apps | High — builds pipelines | High — designs cloud arch |
| Typical deliverable | Deployed API service | Deployed full-stack app | Working CI/CD pipeline | Provisioned cloud resources |
| My current level | Small deployed APIs | Car-Match, this site | Personal CI scripts | AWS internship |
Expanded Process Notes
How I approach building a backend API
- 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).
- 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.
- 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).
- Write CRUD routes — Each resource gets create, read, update, and delete endpoints with input validation and error handling.
- Deploy and document limitations — I deploy to Render and document cold start behavior, missing rate limiting, and other known gaps in the README.
- 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).
