backend-task-api
Shipped: Bookmark service
Repository: https://sgm322.github.io/BookMarks/ Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
I built a lightweight, framework-free Node.js API for managing bookmarks, designed specifically to be easy to review. The README clearly maps out every endpoint and status code, so you know exactly what to expect. The server is rock-solid and returns helpful 400 errors for bad inputs without ever crashing. It also smartly handles duplicate URLs based on a real-world "one bookmark per page" rule. Everything is proven by 49 real HTTP tests that you can run instantly with a simple node --test, requiring absolutely no setup. Repository: https://github.com/Gloweeyahh/bookmark-service Live: https://bookmark-service-zg64.onrender.com/ Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
Built a bookmark service with 4 endpoints: POST/GET /bookmarks, GET/DELETE /bookmarks/:id. Every malformed input (empty url, number instead of string, missing field, url over 2KB) returns 400 with a message naming the exact field -- never a 500. Idempotency is handled by a UNIQUE constraint on the url column: POSTing the same URL twice returns the existing bookmark with 200 instead of creating a duplicate row. A reviewer can verify this by running npm install && npm start , then bash test.sh in another terminal -- it walks through all 8 acceptance cases and prints the real HTTP responses. The README documents the idempotency decision and includes a captured run of this exact output. Repository: https://github.com/GhulamMustafaAnsari/bookmark-service Live: https://bookmark-service.bonto.run/bookmarks Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built a simple Short Link Service using Python, Flask, and SQLite. It allows users to create short links from valid HTTP/HTTPS URLs, redirect to the original URL, count link clicks, and view link statistics. It also validates invalid input and returns HTTP 400, returns HTTP 404 for unknown short codes, and returns the same short code when the same URL is submitted again. A reviewer can verify the acceptance criteria by running the application with python app.py and testing the API at http://127.0.0.1:5000. The README contains the available endpoints and examples for testing the main functionality. Repository: https://github.com/LinaMustafa1/short-link-service Live: Not available. The service runs locally with Flask. Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
I built a Bookmark Service HTTP API designed with strict input boundary validation and idempotency handling. What was built: 1. Endpoints: - POST /bookmarks: Validates input and creates a bookmark, or returns the existing bookmark if repeated. - GET /bookmarks: Retrieves the list of all bookmarks. - GET /bookmarks/:id: Fetches a single bookmark by ID (returns 404 if not found). - DELETE /bookmarks/:id: Deletes a bookmark by ID (returns 204 or 404). 2. Input Validation (Survives Bad Input with 400 status): - Returns 400 Bad Request with an explicit error message naming the 'url' field for: Missing 'url' field Non-string values (e.g., numbers, booleans) Empty strings or whitespace-only inputs URLs exceeding 2 KB in length Invalid URL format or protocols other than http/https - No bad input produces an unhandled 500 error. 3. Duplicate Recognition: - Compares canonical URL strings to identify duplicates. - Sending the same create request twice leaves only one row and returns the existing record with status 200 OK. How a reviewer can verify: - Send test POST requests with empty body, numbers, and strings over 2KB to verify 400 error responses naming the 'url' field. - Send identical valid POST requests twice to verify only one row exists and no duplicate is created. - Check the README.md in the repository for documentation on duplicate handling. Repository: https://github.com/roh155/Bookmark-Service-API Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built a full-stack URL shortener with a React/Vite frontend, Express.js backend, and PostgreSQL database hosted through Vercel and Neon. Users can enter a valid HTTP/HTTPS URL and generate a unique short link. Opening the short link redirects to the original URL, while the Statistics feature displays the link's current click count and stored information. The application also includes URL validation, duplicate URL handling, persistent database storage, and API health checking. A reviewer can verify the acceptance criteria directly from the deployed application by: 1. Entering a valid URL and creating a short link. 2. Opening the generated short URL and confirming it redirects to the original URL. 3. Clicking Statistics and confirming the stored URL and click count are displayed. 4. Opening the short URL multiple times and checking that the click count increases. 5. Refreshing the page or returning later to confirm the link data persists through PostgreSQL. 6. Testing invalid input to confirm that invalid URLs are rejected. 7. Checking the application's health endpoint to verify that the deployed backend is operational. The complete source code and implementation are available in the project's GitHub repository, allowing the reviewer to inspect the frontend, API, database integration, validation, and deployment configuration. Repository: https://github.com/AdyanShaikh/url-shortener Live: https://url-shortener-puce-ten.vercel.app/ Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
The project code has been pushed to GitHub, and the server is deployed and running on Render. I also included the Postman API collection in the repository, so you can import it directly into your Postman workspace and test all the endpoints against the live API. Repository: https://github.com/abbasg-dev/bookmark-api Live: https://bookmark-api-cy0b.onrender.com/ Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built a Flask and SQLite short-link service: https://github.com/quratulain-nayeem/api-suviver A reviewer can run it using the README instructions. POST /links creates a short code, GET /<code redirects and increments the visit count, and GET /links/<code displays statistics. Unknown codes return 404, malformed URLs return 400 before storage, and submitting the same URL twice returns the same code. The service uses 302 redirects, with the caching and visit-count reasoning documented in the README. Repository: https://github.com/quratulain-nayeem/api-suviver Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
What Was Built A bookmark service API with validation at the boundary — rejecting bad input before it reaches business logic. Quick Demo npm install && npm start Create curl -X POST localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url":"https://github.com","title":"GitHub"}' Duplicate (returns 200, not 201) curl -X POST localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url":"https://github.com","title":"Diff"}' List (shows 1 row) curl localhost:3000/bookmarks Bad input (returns 400 with field name) curl -X POST localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url":"not-url"}' Acceptance Criteria Verification 1. Three or more endpoints, each returning a documented status code The service has four endpoints: - POST /bookmarks → returns 201 (created), 200 (duplicate), or 400 (validation error) - GET /bookmarks → returns 200 with array of bookmarks - GET /bookmarks/:id → returns 200, 400 (bad ID), or 404 (not found) - DELETE /bookmarks/:id → returns 204, 400, or 404 2. Malformed input returns 400 with a message naming the field Test it: curl -X POST localhost:3000/bookmarks -H "Content-Type: application/json" -d '{}' Response: {"error":"validation failed","fields":{"url":"required"}} The error names the field (url) and the rule (required). 3. No input produces a 500 Every validation path returns 400: - Empty body → 400 - Wrong type (number instead of string) → 400 - Missing url → 400 - Invalid url → 400 - Unknown fields → 400 - Long strings exceeding limits → 400 4. The same create request sent twice leaves one row Test it: First request - creates row curl -X POST localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url":"https://github.com"}' Second request - returns existing, no new row curl -X POST localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url":"https://github.com"}' List shows only one row curl localhost:3000/bookmarks 5. README explains how repeats are recognized The README has a "Duplicate Detection" section explaining: - URL is used as unique identifier - Database has a UNIQUE constraint on URL - Same URL returns existing bookmark with 200, not a new row - Reasoning: two bookmarks with same URL are the same resource Repository: https://github.com/techtuber9988/bookmark-service Built for the Verified Backend Internship · an API that survives bad input