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
Shipped: Short link service
A short-link HTTP service (Express + TypeScript + MongoDB) that turns a long URL into an 8-character code, redirects visitors to the target, and counts clicks. Endpoints under /v1/api : POST to create ( 201 new / 200 if it already exists), GET /:code to follow ( 302 ), and GET /links/:code/stats for click counts. - Create / follow / count work — test/url.test.ts covers all three end-to-end: fresh code on create, 302 with correct Location , and clicks: 3 after three visits. - 301 vs 302 justified — explicit 302 in src/controller/url.controller.ts ; rationale in README.md ("A note on the redirect"): a cached 301 would bypass the server and undercount clicks, and make links un-editable. - Unknown code → 404 — test asserts 404 with {"error":"shortId: no link found with this code"} , never a silent 200 . - Malformed URL → 400 before storage — validateCreateUrl returns a field-naming error for each case (missing, non-string, empty, 2048 bytes, non-http(s)); tests assert all ten cases return 400 and the DB count stays 0 . - Same URL twice → one code — reverse lookup returns the existing code with created: false , backed by a unique index on redirected url (race fallback catches duplicate-key 11000 ); test verifies the same code and exactly one document. Repository: https://github.com/Firefist111/Short-link Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built Ashorty, a full-stack URL shortener with a React/Vite frontend, Express API, PostgreSQL persistence, URL validation, normalization, duplicate URL reuse, random short codes, redirects, click tracking, and link statistics. It also includes a responsive light/dark interface, Vercel deployment configuration, an MIT license, and the DevConnect badge. A reviewer can verify the acceptance criteria by running npm install , npm test , and npm run build . The tests confirm link creation, redirects, click counting, invalid URL rejection, unknown-code handling, duplicate URL reuse, and URL normalization. For manual review, they can run the API and frontend, create a short link, open it, confirm the redirect and increased click count, view statistics, test search and remove actions, and check the /health endpoint. Repository: https://github.com/azizulabedinazmi/Ashorty-Url-Shortener Live: https://ashorty.vercel.app/ Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
I built a Node/Express/Mongoose bookmark API with CRUD endpoints, strict URL validation, and duplicate detection by normalized lowercase trimmed URL. A reviewer can see the criteria in the README and tests: malformed input returns 400 with a message naming the url field, duplicate create requests keep only one row, and the API exposes create/list/get/delete flows with documented status codes. Repository: https://github.com/Tushar-Sharma-hub/Bookmark-Service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built an HTTP short-link service (Node.js + Express) that creates a short code for a URL, redirects on lookup, and tracks how many times each code has been followed. To verify the acceptance criteria: 1. Clone the repo, run npm install then npm start (listens on port 3000). 2. Run npm test — a self-contained test suite (test.js) exercises every criterion automatically and prints "All tests passed." 3. Or check manually with curl: - POST /links with a valid URL → 201, returns a code - POST /links again with the SAME url → 200 with the same code (no duplicate created) - GET /:code → 302 redirect to the original URL, increments its click count - GET /links/:code/stats → shows clicks incrementing - GET /an-unknown-code → 404, not an empty 200 - POST /links with a malformed url (e.g. "not a url") or a missing url field → 400, with the response naming the bad field, and nothing is stored The README explains why the redirect uses 302 rather than 301: a cached 301 would let browsers skip the server entirely on repeat visits, silently breaking the click counter in a way that can't be reversed once caches pick it up. 302 keeps every follow hitting the server so counting stays accurate. Repository: https://github.com/hibaimran107/short-link-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
Built a zero-dependency Node.js HTTP service for saving bookmarks, with create, list, get-by-id, and delete endpoints. A reviewer can verify the criteria by running node test/acceptance.test.js, which starts the server and automatically checks all five requirements: three-plus endpoints with documented status codes; malformed input (missing url, empty string, a number instead of a string, a 2KB url) returning 400 with a message naming the field; no request producing a 500; and sending the same create request twice leaving exactly one row, since the service keys on the url itself and returns the existing bookmark with a 200 instead of creating a duplicate. The README explains the reasoning behind that dedupe approach and has curl examples for manual verification too. Repository: https://github.com/mohammedoomatia-max/bookmark-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
i tried build as much as the same which you requested Repository: https://github.com/sarvarbekbro/URL-shortner Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
What I built: A Flask + SQLite URL shortener with three endpoints: POST /links (create), GET /<code (redirect + count visit), GET /links/<code /stats (check URL + click count). All input is validated before it touches the database — bad requests get 400 with the exact field and rule that failed, never a 500. Short codes are a hash of the URL, so the same URL always maps to the same code, making creation idempotent. How a reviewer can verify it: Create/follow/count — POST /links → 200 + code; GET /<code → 302 redirect; stats endpoint shows clicks going up each follow. 301 vs 302 — README explains why 302 was chosen (not cached, so clicks are counted reliably). Unknown code → 404 — confirmed by hitting a code that was never created. Malformed URL → 400, nothing stored — confirmed by posting an invalid URL and checking its stats never resolve. Duplicate URL → same code — confirmed by posting the same URL twice and comparing the two responses. All verifiable with the curl/PowerShell commands in the README. Repository link: https://github.com/hassannnn13/Shortlink-service.git Repository: https://github.com/hassannnn13/Shortlink-service.git Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
I built a bookmark API with create, list, fetch-by-id and delete, each returning a documented status code. The live demo page has a "Run all checks" button that runs every acceptance criterion against the deployed server and shows each request with its expected and actual result. Node, Express 5 and SQLite Repository: https://github.com/Kam-ino/DevConnect-Internship/tree/main/BookmarkService Live: https://devconnect-internship-bookmark-service.onrender.com Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
Repository: https://github.com/VasiliSolap/bookmark-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built a Short Link Service (URL Shortener API) using Python (Flask) that converts long URLs into short codes, performs redirects, tracks click metrics, and robustly handles invalid input. Here is how a reviewer can verify that all acceptance criteria are met: Repository: https://github.com/yanayem/Task-an-API-that-survives-bad-input Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
Bookmark Service An HTTP service for saving bookmarks. A caller can create a bookmark, list their own, fetch one by id, and delete one. The interesting part is not the happy path. It is what happens when a caller sends an empty URL, a number where a URL belongs, no URL at all, or a URL that is two kilobytes long — and what happens when the same bookmark is sent twice. Repository: https://github.com/R0wanAdel/Bookmark-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
Built a Flask-based short-link HTTP service that creates short codes for valid HTTP/HTTPS URLs, redirects users with a deliberate 302 response, and tracks redirect counts. The service provides endpoints for creating links, following links, and viewing statistics. Invalid URLs return 400 with an error identifying the url field, unknown codes return 404, and submitting the same URL twice returns the existing short code instead of creating a duplicate. The README documents the API, validation behavior, duplicate handling, and the reasoning behind using 302 redirects. Automated tests cover creation, redirects, counting, malformed input, unknown codes, and duplicate submissions, with all 7 tests passing. The deployed API is available at the live demo URL above. Repository: https://github.com/kiths-bit/short-link-service Live: https://short-link-service-6vef.onrender.com/ Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
I built a short link service with FastAPI and PostgreSQL (SQLAlchemy + Alembic). POST /links takes a URL and returns a 6-character code. GET /links/{code} redirects to the original URL and counts the follow, and GET /links/{code}/stats shows the count without counting it. How to check the criteria (full setup steps are in the README): - Bad input: a malformed URL, an empty body, or a wrong type returns 400 with the field name and location, and nothing is stored. - Unknown code: returns 404 on both the redirect and stats endpoints. - Same URL twice: returns the same code. A unique constraint on the URL backs this up in the database. - Redirect and counting: follows return 302 (not 301, so browsers don't cache it and skip the counter). Each follow adds exactly 1 using one atomic UPDATE. - Code collisions: handled by retrying when the database rejects a duplicate code. - Tests: run "pytest -v" for 12 passing tests against a separate test database. They cover each point above. The work is split across several PRs: validation, create link, redirect and click counting, database, tests, and README. Known limits: no authentication or rate limiting, and the GET /links list endpoint is only a placeholder. Repository: https://github.com/Ramsha-Anwar/short-link-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
Repository: https://github.com/saikatdas47/short-link-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Short link service
What I built: I built a short link service in Node.js. You send it a long URL and it gives back a short code. When someone opens the short code, it sends them to the original URL and counts that visit. It has three endpoints: - POST /links creates a short link. - GET /:code follows the short link. - GET /links/:code/stats shows how many times it was followed. How to check it: Start the server with npm start. In a second terminal, run npm run demo. The script runs every check below and prints the status code next to each one. You can also run npm test to see all 32 tests pass. 1. Creating, following and counting each work. The demo creates a link and gets 201. It follows the link twice, then checks the stats and sees a count of 2. 2. 301 or 302 is chosen on purpose. I used 302. Browsers remember a 301, so repeat visits would skip my server and never be counted. A 301 also can’t be undone once a browser has saved it. The reason is written in the README under “302, not 301”. 3. An unknown code returns 404. The demo opens a code that doesn’t exist and gets a 404 with an error message, not an empty 200. 4. A malformed URL is rejected with 400 before storage. The demo sends “not a url” and a javascript: link. Both get a 400 and the message names the field, for example {"error": "url must use http or https", "field": "url"}. The checks run before anything is saved, and a test confirms nothing was stored. Broken JSON also gets a 400, not a 500. 5. The same URL submitted twice does not create two codes. The demo sends the same URL twice. The first time gets 201 and the second gets 200 with the same code. A test also sends 20 identical requests at once and checks that only one link is stored. The README has the full list of endpoints, the error codes and the known limits.
Shipped: Short link service
Built a Short Link REST API using Python, FastAPI, SQLite, Pydantic, and Pytest. Implemented features: - Create short links and redirect visitors to their original URLs. - Track visit counts and retrieve link statistics. - Return HTTP 404 for unknown short codes. - Validate malformed URLs and return HTTP 400 with field-specific error details before storing invalid data. - Reject unexpected request fields. - Reuse the existing short code when the same URL is submitted again, avoiding duplicate records. - Persist links and visit counts in SQLite. How to verify the acceptance criteria: The repository includes a README with setup instructions and API examples, plus automated tests in tests/test main.py . All 6 tests pass, covering link creation, duplicate URL handling, invalid input without database storage, unknown codes, redirects and visit counting, and unexpected fields. Run locally using the instructions in the README, then execute python -m pytest -v to verify the tests. Repository: https://github.com/mradipatil770-cpu/short-link-service Repository: https://github.com/mradipatil770-cpu/short-link-service Built for the Verified Backend Internship · an API that survives bad input
Shipped: Bookmark service
I built a Bookmark Service REST API using Node.js and Express. Features and Acceptance Criteria met: - Endpoints: POST, GET, GET/:id, and DELETE are fully implemented. - Robust Input Validation: Strict boundary checks reject malformed or empty inputs with a clean 400 Bad Request status, ensuring zero 500-level server crashes. - Idempotency: POST requests check if the URL already exists; submitting the same URL twice prevents duplicates and returns 200 OK with the existing record. - Testing & Setup: Detailed instructions are provided in the README.md file for running the server locally and testing the endpoints. Repository: https://github.com/oliviamol/bookmark-service Built for the Verified Backend Internship · an API that survives bad input