Streamline PostgreSQL Projects with Vollna

We’re looking for a Python developer to build a small authentication microservice and a companion scraping endpoint to be used by our internal dashboard team.

Project Scope

You will create a lightweight backend service that processes external data from a public website and exposes it through a clean REST API.
The system must include authentication, background scraping, and a simple admin interface.

Tasks
- Build a scraping module (Python Script / Requests / BS4 or Playwright)
- Scrape public, non-login-protected data from a simple website endpoint
- Normalize the result and save it to PostgreSQL.
- Create a small API service
- Endpoint /auth/login
- Endpoint /data/latest → return the most recent scraped items
- Endpoint /data/refresh → triggers a new scrape operation
- Add background execution
- Use Celery + Redis (Django stack) OR RQ / APScheduler (Flask stack)
- “Refresh” endpoint should queue a task, not execute scraper synchronously
- Set up Docker support
- Dockerfile for the service

I’m looking for an experienced Ruby on Rails developer to optimize a performance issue in one of our API endpoints. The API is returning data correctly, but it’s currently slowed down due to an ActiveRecord N+1 query problem.

The goal is to:

Identify the inefficient query

Implement proper eager loading (includes, preload, joins, etc.)

Reduce response time and improve API performance

Ensure zero impact on existing logic

This is a small but important task for someone who understands Rails performance tuning, SQL optimization, and clean API architecture.

Ideal for a Rails expert who has solved similar N+1 ActiveRecord issues in production apps.

I am looking for an experienced full-stack developer (or small development team) to build a cashback rewards platform consisting of:

A fully functional cashback website

A Chrome browser extension

Backend tracking integrated with affiliate networks

A user dashboard with earnings and payout functionality

This project should operate similarly to Rakuten, Honey, Capital One Shopping, and TopCashback, but with a simplified MVP and structured architecture that can be expanded later.


Scope of Work
1. Cashback Website

The website should include:

Homepage and merchant directory

Individual merchant pages showing cashback percentages

Ability to generate and manage affiliate tracking links

Automated outbound click tracking with UTMs

User registration and login (email or Google login preferred)

User dashboard displaying:

Lifetime earnings

Pending earnings

Confirmed earnings

Available balance

Admin dashboard for:

Adding/editing merchants

Adjusting cashback percentages

Viewing and managing transactions

Manual balance adjustments


2. Chrome Browser Extension (Manifest V3)

The browser extension must:

Detect retailer websites automatically

Display a popup prompting users to activate cashback

Trigger affiliate tracking automatically in a background tab

Show confirmation when cashback is successfully activated

Allow login and sync with the same user account from the website

Display user earnings inside the extension


3. Backend / API Requirements

Robust click tracking system

Webhook listeners for affiliate networks (Impact, Awin, CJ, ShareASale, etc.)

Transaction lifecycle: Pending → Confirmed → Payable

Commission calculation and assignment to users

Internal tools for customer support and admin adjustments

Ability to add integrations with additional affiliate networks later


4. Affiliate Network Integrations

The platform must support integration with at least the following networks:

Awin

Impact / Radius

CJ Affiliate

ShareASale

Optional but preferred:

Temu Affiliate Program

AliExpress / Alibaba affiliate APIs

All APIs and documentation will be provided.


5. Payout System (Phase 2 – Optional for MVP)

If you can build this now, please specify:

PayPal, Cash App, or Venmo payouts

Gift card payouts via Tremendous or Tango API

Stripe Connect for automated payments


Technical Preferences (Flexible)

Preferred (but not required) stack:


Frontend:

Next.js or React

TailwindCSS


Backend:

Node.js, Express, or NestJS

PostgreSQL or MySQL

Prisma ORM

Redis for caching


Hosting:

Vercel, AWS, or similar


Extension:

JavaScript or TypeScript

Manifest V3 compliant

Background worker + content scripts

If you prefer alternative technologies, feel free to propose them.


Deliverables

Fully functional cashback website

Fully functional Chrome extension

Admin dashboard

User dashboard

Database schema and setup

Tracking and webhook system

Deployment-ready code

Documentation for setup and ongoing maintenance

Post-launch support for 30–60 days (preferred)


Ideal Candidate Requirements

Proven experience building browser extensions (required)

Experience with affiliate tracking, redirects, cashback logic, or coupon/cashback platforms

Strong understanding of secure authentication systems

Experience with scalable backend systems

Ability to build clean UI/UX and mobile-responsive layouts

Ability to communicate clearly, provide updates, and propose solutions


Bonus experience:

Affiliate marketing or adtech platforms

Coupon websites or similar extensions

API integrations with affiliate networks




Timeline

MVP delivery goal: 6–10 weeks

Full-featured expansion (optional): 2–4 months

Budget - Open to reasonable offers based on experience. $5k is a placeholder

Seeking an experienced developer or team — not beginners. Thank you!

Description:
1. We are building SellersGPT, a multilingual AI-powered SEO CMS designed for B2B enterprise websites.
2. Each website instance is independently deployed (1 DigitalOcean droplet + 1 PostgreSQL database + 1 DO Agent Workspace).
3. We are looking for an experienced full-stack developer or a small development team to implement Phase 1 of the system.

Core Modules to Build
(1) CMS
Pages (block-based)
Blogs
Products
Categories
Admin and Editor roles
(2) Multilingual Publishing
English as the primary source language
Support 9 additional languages: ES, DE, FR, PT, IT, TR, RU, NL
Manual translation triggers
Auto hreflang and sitemap generation
Localized URL routing
(3) AI Content Engine
Two AI pipelines are required:
Writer Model (content generation)
Reviewer Model (SEO quality control)
The AI engine will be used for:
Rewriting industry news
Generating keyword-based long-form articles
Enhancing manually written company news
Creating structured SEO content with H1/H2/H3
Generating FAQs
Suggesting meta titles and meta descriptions
(4) Industry News Automation (APITube)
The system must:
Fetch news through APITube API on a schedule
De-duplicate articles
Rewrite articles into long-form content using AI
Apply SEO review
Auto-generate slug, meta title, meta description, FAQ, and internal link placeholders
Publish English version, then auto-translate to 9 languages
Sync clean_text into DigitalOcean Agent Workspace
Auto-create social media post drafts
(5) Bulk Keyword Article Generator
This module allows uploading a CSV or XLSX file with multiple keywords.
For each keyword, the system will:
Generate a long-form SEO article
Apply Reviewer Model quality checks
Auto-publish English content
Translate into 9 languages
Sync clean_text into the Agent Workspace
Create optional social media post drafts
(6) Social Media Automation
Platforms: LinkedIn, Facebook, Twitter / X
Features:
OAuth connection
AI-generated posts
Scheduled posting
Weekly digest generation
Auto-create posts from APITube and keyword-generated content
(7) DO Agent Workspace Integration
Sync content to DO Agent Workspace (title, clean_text, URL, content type)
Provide data for an embedded website chatbot
Optional: Facebook Messenger chatbot integration

Tech Stack Requirements
Next.js or Astro (static site generation required)
Node.js + TypeScript
PostgreSQL + Prisma
DigitalOcean deployment experience
OpenAI API integration
OAuth implementation for LinkedIn, Facebook, Twitter
Experience building automated content pipelines is a strong plus

Deliverables
CMS backend and admin panel
Multilingual module
AI Writer and Reviewer pipelines
APITube news automation module
Bulk keyword article generator
Social media automation features
DO Agent Workspace chatbot integration
Deployment setup and basic documentation

To Apply
Please include:
Relevant past projects
Tech stack you propose for this project
Estimated development timeline and cost

Project: Build and optimize the core database for an RFP (Request for Proposal) Response Application. This app will help teams collaborate on, manage, and streamline the creation of complex proposal documents.

Role: You will be responsible for designing, implementing, and securing the PostgreSQL database within Supabase. Your work will form the foundation of the application, ensuring data integrity, performance for complex queries, and real-time collaboration features. You will work closely with the frontend/backend developer(s) to define the API layer (Supabase functions and RPCs).

Key Responsibilities:

Design and implement a normalized, efficient PostgreSQL schema for users, RFP projects, questions, content libraries, assignments, and version history.

Implement Row Level Security (RLS) policies to ensure users can only access appropriate project data.

Design and write PostgreSQL functions and stored procedures for critical business logic (e.g., scoring responses, generating document drafts).

Optimize queries and indexes for performance, especially for full-text search within proposal content.

Set up real-time subscriptions for collaborative editing features.

Advise on best practices for database migrations, backups, and monitoring within Supabase.

Must-Have (Non-Negotiable):

Proven expertise in PostgreSQL (advanced queries, performance tuning, indexing strategies).

Hands-on experience with Supabase, specifically: RLS policy design, database functions, and the Supabase client/library.

Strong understanding of database design principles (normalization, relationships, data integrity).

Experience implementing full-text search in PostgreSQL (using tsvector/tsquery).

Ability to write clear, secure SQL and communicate design decisions effectively.

Strongly Preferred:

Experience building databases for collaborative, document-heavy, or content management applications.

Familiarity with the Supabase JavaScript/TypeScript client for collaboration with frontend devs.

Knowledge of PostgreSQL extensions relevant to the project (e.g., pgcrypto for encryption, uuid-ossp).

Understanding of how to structure data for real-time features using Supabase’s Realtime engine.

Preferred But Not Necessary:

Experience in the proposal/RFP domain or similar (e.g., legal tech, compliance platforms).

Familiarity with generating database diagrams and documentation.

Knowledge of Supabase Auth and its integration with RLS.

Would Be Nice (Soft Skills):

Proactive communicator. This is a foundational role; you must ask questions and anticipate data needs.

Devil's advocate. This position requires a willingness to defend your position when it's the better solution.

Problem-solver with a product mindset, thinking about how the data structure enables application features.

Able to deliver clean, well-documented work on a agreed timeline.

Java Spring Boot Developer (Micro services) – 3+ Years Experience

We are looking for an experienced Java Developer (Spring Boot) with strong hands-on expertise in microservices-based development and deployment. The ideal candidate should be able to design, develop, integrate, and deploy scalable micro services in a production environment.

Key Responsibilities

Develop and maintain microservices using Java, Spring Boot, Spring Cloud.
Implement RESTful APIs, integrations, and backend business logic.
Work with MySQL/PostgreSQL, JPA/Hibernate, caching & messaging queues.
Manage deployments on AWS / Docker / Kubernetes (any cloud experience preferred).
Optimize system performance, troubleshoot issues, and ensure high availability.
Collaborate with team to deliver clean, efficient, and well-documented code.

Requirements

3+ years of experience in Java & Spring Boot.
Strong understanding of Microservices architecture.
Experience in API development, CI/CD pipelines, Docker, Git.
Ability to work independently with minimal supervision.
Good communication and problem-solving skills.

Project Type

Ongoing development & enhancements
Freelance / remote work with flexible timing

Faculti’s next phase is to turn its expanding academic index—6,000 papers now and 100–400k incoming—into the backbone of a new flagship product: Faculti Research, a live search page that unifies semantic discovery across interviews, posts, clips, abstracts, authors, and subjects. And our current AI functionality - ask a question, summaries, briefings

A continuous ingestion pipeline will pull data from free global sources like the current OpenAlex, Semantic Scholar, PubMed, arXiv, (we need to add Crossref, Europe PMC, DOAJ, SSRN metadata), transforming titles, abstracts, authors, and categories into transformer embeddings stored in pgvector.

This same engine will power Video IQ sidebar on every video page.

To build

Faculti Research Page
category/topic discovery hubs showing trending research
auto-generated researcher profiles
institution pages mapping research output
and a personalised feed of recommended clips and papers.
As the index scales toward a million vectors, Faculti becomes not just a video platform but a full academic intelligence system—combining the semantic depth of Semantic Scholar, the explainability of Perplexity, and the citable video layer unique to Faculti—all built entirely from abstracts and interviews

We have a lot of the backend for our sidebar

We are building an advanced AI-driven Real Estate Automation Platform designed to simplify property management, automate workflows, and provide intelligent insights to users.
The platform includes:
→ A public-facing landing page
→ A secure dashboard for property owners, agents, and admins
→ AI chatbot for document management, property data analysis & customer support
→ Automated daily operations with RPA tools and custom workflows

We are looking for a skilled Full-Stack Developer experienced in React, Node.js, TypeScript, AI, real-time systems and cloud technologies.

Responsibilities
Frontend Development (React + Redux Toolkit + Bootstrap)

→ Build responsive and interactive UI modules.
→ Implement state management using Redux Toolkit.
→ Create dynamic dashboards, charts, and data visualization.
→ Integrate live updates using Socket.io.
→ Develop user onboarding screens, profile pages, and property listing components.

Backend Development (Node.js + Express + TypeScript + TypeORM)

→ Develop scalable REST APIs using TypeScript.
→ Design database models using TypeORM.
→ Implement secure authentication and authorization (Google OAuth + JWT).
→ Create micro modules for notifications, user roles, and property management.
→ Set up backend validation, caching, and performance optimization.

Database & Cloud (PostgreSQL + AWS S3 + Cloud Services)

→ Manage relational data, indexing, and optimized queries in PostgreSQL.
→ Implement AWS S3 for secure file and document uploads.
→ Handle cloud folder structure for property documents, images & KYC records.

AI & ML Integration

→ Integrate an AI assistant for:
— Property document summarization
— Chat-based support
— Real estate trend predictions
— Automatic description generation for listings
→ Use LangChain pipelines with a vector database (ChromaDB).
→ Implement Hugging Face models for NLP-driven workflows.
→ Build an AI-based "Smart Search" for properties, leads & documents.

Automation & RPA

→ Build workflow automations using n8n for:
— Lead routing
— Report generation
— Document verification
→ Use UI.Vision for robotic process automation to extract data from property portals.
→ Implement auto-notification flows for agents and tenants.

Real-Time Features (Socket.io)

→ Implement real-time communication channels.
→ Build live visitor tracking for listings.
→ Enable instant updates for property status, approvals, and messages.

Meta Business Suite Integration (WhatsApp Automation)

→ Configure WhatsApp templates for property inquiries & reminders.
→ Set up WhatsApp automation workflows for lead follow-ups.
→ Connect WA-Flow with backend for messaging triggers.

If you are ready to work on cutting-edge AI systems and real-time platforms, this role is for you.

We need an experienced Google Cloud Platform specialist to migrate our SQLite database to AlloyDB using VPC Private Service Connection.

Scope of Work:
1. Set up AlloyDB instance with VPC Private Service Connection
2. Migrate SQLite database to AlloyDB using pgloader

Budget:
- $90 USD for AlloyDB and VPC setup
- $90 USD for database migration using pgloader
- Total Project Budget: $180 USD

Required Qualifications:
- Proven experience with Google Cloud Platform (GCP)
- Hands-on expertise with VPC configuration and Private Service Connection
- Strong background in AlloyDB and PostgreSQL

Application Requirements:
To be considered, your proposal must include:

1. Description of a similar GCP project you've completed that involved:
- AlloyDB or PostgreSQL via VPC Private Service Connection configuration

We’re building a suite of B2B SaaS tools for Amazon sellers and agencies. This is a long-term position, not a one-off project. You will be our primary developer as we build and maintain multiple dashboards and web applications over the coming years. You need to be comfortable owning a codebase, making technical decisions, and shipping real product – not just small CRUD apps.

The core stack we expect you to use:
– Backend: Node.js (TypeScript preferred) with REST APIs (Express/Fastify). Python (FastAPI) for ETL/background jobs is a strong plus
– Frontend: React (Next.js or SPA), component-based UI, responsive design, light/dark mode basics
– Data: PostgreSQL (preferred) or PostgreSQL + some MongoDB, schema design for multi-tenant SaaS, aggregations, indexing
– Infrastructure: basic AWS / cloud deployment, Docker, Git/GitHub, simple CI/CD

What you’ll actually be doing (first project – Account Health Dashboard):
– Implement backend services that ingest JSON/CSV reports from Cajari (Amazon Seller Central data extraction), normalize them, and store them in a multi-tenant database
– Design and implement database schemas for clients, seller accounts, policy violations, metrics snapshots, and workflow/work history
– Build a secure backend with role-based access (Admin, Staff, Client) and strict tenant isolation on every query
– Expose clean REST APIs for the frontend (metrics, trends, filters, pagination)
– Turn detailed dashboard designs (tables, filters, charts, badges) into reusable React components
– Implement account-health KPIs, trends, and alert logic on the backend and surface them cleanly in the UI
– Handle pagination, filtering, and sorting for large datasets (10k+ rows per account)
– Pay attention to reliability, data validation, and simple but solid error handling throughout the stack

What you’ll do next (this is ongoing work, not just one dashboard):
– Build additional monitoring dashboards for different Amazon / e-commerce data sources
– Develop client-facing reporting tools and self-service portals
– Create internal operations and case-management applications for our team
– Implement automation and workflow tools (alerts, queues, background jobs, scheduled reports)
– Help shape architecture decisions as the product suite grows over time

Requirements:
– 3–5+ years of full-stack experience with Node.js and React (Python experience is a strong plus)
– Very comfortable designing relational schemas and writing clean, efficient SQL queries (PostgreSQL strongly preferred)
– Proven experience building at least one serious dashboard or B2B SaaS product end-to-end (not just tutorials)
– Strong understanding of authentication, authorization, and multi-tenant patterns (tenant_id, RBAC, etc.)
– Ability to read existing HTML/CSS or Figma and refactor it into reusable components instead of starting from scratch every time
– Solid Git/GitHub habits, code reviews, and basic testing (unit/integration)
– Good written English and willingness to communicate clearly in async updates and short Loom walkthroughs when needed

Nice-to-have:
– Prior experience with Amazon Seller Central or other e-commerce dashboards
– Familiarity with queues/background workers and ETL/data pipelines (BullMQ, Celery, cron-based workers, etc.)
– Experience with charting libraries (Recharts, Chart.js, etc.)
– Experience deploying and operating apps on AWS or similar cloud providers

This is NOT a one-off project. We are looking for a long-term partner who can stay with us, own the codebase, and continue building additional dashboards, internal tools, and web applications after the first version ships.

When you apply, please:
– Answer the screening questions carefully
– Include links to 1–2 dashboards or SaaS apps you actually built (GitHub and/or live demos)
– Briefly confirm your weekly availability and your timezone

• Walk me through one B2B SaaS product you built. What was the stack, your role, and one complex technical problem you solved?
• How do you approach designing a multi-tenant database schema in PostgreSQL for a SaaS application?
• Please describe how you'd build an ETL pipeline that pulls JSON data from an external API daily and stores it with full history tracking. What would your schema look like?
• Are you able to commit to working 40 hours/week with 4-5 hours daily overlap with Eastern Standard Time?
• When are you available to begin working?

JOB DESCRIPTION: SENIOR AI ENGINEER (APPLIED AI & BACKEND)
​Vị trí: Senior AI Engineer / Founding Engineer
Báo cáo trực tiếp: CTO
Mô hình làm việc: Hybrid / Remote (Linh hoạt theo kết quả)
​1. VỀ G-LIFE VN & VAI TRÒ CỦA BẠN
​G-LIFE VN không tuyển nhân viên viết code. Chúng tôi tìm kiếm người kiến tạo (builder). Chúng tôi đang xây dựng một nền tảng EdTech/Lifestyle ứng dụng Generative AI để giải quyết các bài toán thực tế, không phải làm "tính năng cho vui" (gimmick).
​Bạn sẽ là Senior AI Engineer đầu tiên, nắm giữ "bộ não" của sản phẩm. Bạn không chỉ viết API; bạn chịu trách nhiệm làm cho AI "hiểu" người dùng, trả lời chính xác dựa trên dữ liệu của G-LIFE (RAG), và chạy mượt mà trên hạ tầng Serverless.
​2. TRỌNG TRÁCH CHUYÊN MÔN (MISSION)
​Bạn sẽ dành quỹ thời gian của mình để giải quyết 3 bài toán lớn:
​A. AI System Integration & Orchestration (60% - The Core)
​Xây dựng "AI Gateway": Thiết kế và triển khai lớp trung gian (sử dụng Python FastAPI hoặc Supabase Edge Functions) để quản lý, điều phối và tối ưu các luồng gọi tới LLM (OpenAI, Gemini, Anthropic).
​Làm chủ RAG (Retrieval-Augmented Generation): Đây là trái tim của hệ thống. Bạn sẽ thiết kế luồng dữ liệu từ Knowledge Graph (trên Supabase) -> Vector Store (pgvector) -> LLM để đảm bảo AI trả lời đúng ngữ cảnh, không bịa đặt (hallucination).
​Prompt Engineering & Management: Quản lý versioning các prompt template như quản lý code. Đảm bảo đầu ra của AI luôn là JSON chuẩn xác để App có thể render giao diện tương tác.
​B. Backend Architecture & Data (30% - The Foundation)
​Supabase / PostgreSQL Master: Thiết kế schema CSDL tối ưu cho cả dữ liệu quan hệ (Relational) và dữ liệu vector (Vector Search). Lưu trữ lịch sử chat và hành vi học tập để cá nhân hóa trải nghiệm.
​High Performance API: Xây dựng API (Python/TypeScript) hỗ trợ Streaming Response (trả lời từng từ như ChatGPT) để tối ưu trải nghiệm người dùng (UX).
​Data Privacy: Thiết kế cơ chế "Redaction" để lọc bỏ thông tin nhạy cảm (PII) của người dùng trước khi gửi request sang các LLM provider.
​C. Evaluation & Optimization (10% - The Quality)
​AI Quality Assurance: Xây dựng bộ test tự động (Eval set) để đánh giá chất lượng câu trả lời của AI mỗi khi thay đổi prompt hoặc model.
​Cost & Latency Control: Theo dõi sát sao Token usage (tiền) và Latency (tốc độ). Cân bằng giữa việc dùng model "khôn nhất" (nhưng đắt) và model "đủ dùng" (nhưng rẻ).
​3. CHÂN DUNG ỨNG VIÊN (REQUIREMENTS)
​Chúng tôi tìm kiếm tư duy "Pragmatic Engineer" - Kỹ sư thực dụng, giải quyết vấn đề, không vẽ vời.
​Bắt buộc (Must-Have):
​3+ năm kinh nghiệm Backend: Thành thạo Python (ưu tiên) hoặc Node.js. Sẵn sàng làm việc sâu với hệ sinh thái Supabase / PostgreSQL.
​Kinh nghiệm thực chiến với RAG: Đã từng xây dựng và deploy ứng dụng sử dụng Vector Database (pgvector, Pinecone, Weaviate...) lên môi trường production. Hiểu rõ các vấn đề của Semantic Search.
​Tư duy Sản phẩm (Product Mindset): Bạn không chỉ care code chạy được, bạn care người dùng có nhận được câu trả lời hữu ích không. Bạn biết khi nào nên hy sinh độ chính xác 1% để đổi lấy tốc độ nhanh hơn 50%.
​AI Integration: Có kinh nghiệm xử lý các vấn đề thực tế của LLM (Context window limit, Rate limiting, Structured Output).
​Điểm cộng lớn (Nice-to-Have):
​Kinh nghiệm với các framework AI Orchestration như LangChain hoặc LlamaIndex.
​Hiểu biết về lĩnh vực EdTech, Recommendation System hoặc Personalization.
​Đã từng build sản phẩm từ 0 đến 1.
​4. QUYỀN LỢI & VĂN HÓA (THE OFFER)
​Sở hữu (Ownership): Lương cạnh tranh + ESOP (Cổ phần thưởng). Bạn là thành viên nòng cốt, thành công của G-LIFE là tài sản của bạn.
​Quyền tự quyết (Autonomy): Bạn làm chủ stack công nghệ trong phạm vi trách nhiệm. CTO là người đối thoại và hỗ trợ, không phải người cầm tay chỉ việc.
​Môi trường: Văn hóa "No Bullshit". Chúng ta tranh luận dựa trên data và logic, không dựa trên chức vụ.
​Tài nguyên: Được cấp ngân sách để trải nghiệm các model AI mới nhất, các công cụ dev tốt nhất

Skills: Node.js, PostgreSQL, Payment Gateway Integration, AI/RPA development, API Integration

Modern Furniture Inventory App - Final Proposal
1. Overview
The Modern Furniture Inventory App is a complete cross-platform (Android and iOS)
solution designed for furniture showroom management. It handles inventory, staff operations, salary
tracking,
and user approvals within a secure and easy-to-use system. The app features admin and staff roles,
real-time
activity logs, automated salary calculations, and a clean modern UI that matches the premium
furniture aesthetic.
2. Key Features
- Cross-platform mobile app (Flutter) for Android and iOS
- Role-based login (Admin & Staff)
- Simple login using Name and Password (no email required)
- Staff registration with Name, Phone Number, Password, and Re-enter Password
- Admin approval required for all new staff registrations
- Real-time inventory management with stock update (+/-) buttons
- Automatic monthly salary calculation with rounding logic
- Activity feed with dynamic timeline and flow layout
- Profile section for both Admin and Staff
- Secure backend authentication (Spring Boot + JWT)
- Modern UI design inspired by furniture showroom branding
3. Staff Management & Salary System
Admin can view all staff, approve new registrations, and manage salary details.
- Staff Tab includes:
- Pending Requests: Admin can Approve/Reject new staff
- Active Staff List: Displays approved staff with details
- Salary Calculator: Adjust leaves (+/-), toggle half-day, auto-calculate final salary
- Salary Formula:
Per Day Salary = Base Salary / Days in Month
Deduction = Leaves x Per Day Salary
Final Salary = Base Salary - Deduction (rounded to nearest 5 or 0)
- Example: Base Rs. 10,000, 2.5 days leave -> Rs. 9,170
- Total Monthly Salary: Automatically calculated for all staff combined
4. Profile Section
Profile pages for Admin and Staff include:
- Profile photo upload
- Name, Phone Number, Date of Birth, Address
- Role and Account Status
- Edit Profile option (Admin only for staff)
- Logout button with secure authentication
- Smooth teal gradient header with camera icon overlay
5. Activity Feed - Flowing Timeline
The Activity Feed features a vertical timeline-style layout showing updates like stock changes,
new additions, or uploads. Each entry includes:
- User name
- Action type (Added, Updated, Deleted, Uploaded)
- Item name
- Timestamp
- Icons for each action type and smooth glowing teal dots on the timeline.
6. Technical Architecture
Frontend: Flutter (single codebase for Android & iOS)
Backend: Spring Boot (Java)
Database: PostgreSQL
Authentication: JWT Token-based security
Storage: Firebase/AWS for product images
Hosting: Render or AWS
Version Control: Git + GitHub
Deployment: Google Play Store and Apple App Store
7. Color Palette & Design
Primary Color: #00B7B3 (Teal Blue)
Secondary Color: #084C61 (Dark Teal)
Accent Color: #4EE0D0 (Aqua Mint)
Background: #F8FAFA (Off White)
Typography: Inter or Poppins
Design: Rounded corners (24px), soft shadows, minimal layout with premium feel
8. Navigation Structure
Admin Navigation Tabs:
1. Home - Inventory Dashboard
2. Activity - Activity Feed
3. Staffs - Staff Management & Salary
4. Profile - Admin Details
Staff Navigation Tabs:
1. Home - View and update inventory
2. Activity - Track updates
3. Profile - Personal details
9. Future Updates & Scalability
- Add 'Manage Users' screen for promoting/demoting staff to admin
- Multi-branch admin roles (Super Admin / Branch Admin)
- Auto-sync cloud backup
- Monthly export of salary reports (CSV or PDF)
- Push notifications for updates
- Light/Dark mode
10. Summary
The Modern Furniture Inventory App provides an all-in-one solution for managing
furniture showroom operations. It merges modern UI design with smart business logic -
covering inventory control, staff salary automation, activity tracking, and profile management.
Built for scalability, security, and simplicity, it is ready for both single-showroom and multi-branch
setups

Skills: PHP, Graphic Design, Mobile App Development, SQL, UX / User Experience, Git, iOS Development, Flutter, GitHub, Spring Boot

We are building a large-scale sports data and prediction platform with Next.js, GraphQL, Prisma, PostgreSQL, and AWS.
Our live experience depends on fast, accurate, and efficient synchronization with third-party sports APIs such as SportMonks.

We’re looking for a backend engineer who can take complete ownership of the real-time data layer — optimizing polling, architecting a reliable WebSocket system, and ensuring users receive live match updates at the same speed as leading sports apps, while staying within API rate limits.

*** Please read thoroughly or your application could be denied!! ***

Please read the entire post, include the answers to the questions listed along with your estimate or your application will be denied.

Project Overview

I’m building an MVP for a multi-tenant SaaS platform that includes:
• A backend retrieval API (built by a separate backend engineer)
• A React/Next.js frontend (built by a separate frontend engineer)
• A Postgres + vector database
• Requirements for clean staging and production environments

I need a DevOps/Infrastructure engineer to configure the hosting, deployments, environment variables, and domain routing so the system is stable, secure, and demo-ready.

This is a light DevOps role—simple, clean SaaS infra setup. No Kubernetes, no heavy AWS architecture.

Scope of Work (Deliverables)

1. Backend Deployment (Render or Railway)

Set up the backend API with:
• Deployment to Render.com or Railway.app
• Environment variables (DB URL, API keys, secrets)
• Connection to Postgres + vector DB
• Staging and Production services
• Auto-deploy from GitHub main branch
• Basic logs and error monitoring

2. Frontend Deployment (Vercel)

Set up the Next.js frontend with:
• Staging environment
• Production environment
• Environment variables
• Domain routing (app.domain.com)
• SSL certificates / HTTPS
• Automatic deploy pipeline

3. Database & Vector Store Connectivity

Ensure the backend can securely connect to:
• Supabase/Postgres
• Vector database (pgvector or equivalent)

You do NOT design schemas — just infrastructure connectivity.

4. Environment Isolation (Critical)

Configure:
• Staging environment
• Developers use this
• Test documents only
• Full developer access
• Production environment
• Locked down
• Only I can upload real documents
• Developers get restricted or no access

Proper isolation is essential.

5. Domain / DNS / Routing Setup

Configure routing for both environments:
• DNS records for frontend
• DNS records for backend
• SSL/HTTPS
• Health checks
• URL testing and confirmation

Domain is owned by me; you get limited access only.

6. Basic CI/CD

Light, simple pipelines:
• Frontend auto-deploys from GitHub → Vercel
• Backend auto-deploys from GitHub → Render/Railway

No complex YAML files or container clusters.

7. Security & Secrets Management

Handle:
• API keys via environment variables
• Safe storage of secrets
• Proper staging vs production key separation
• No sensitive data visible to developers in production

8. Handoff Documentation (Deployment Runbook)

A short document explaining:
• How staging & production are configured
• How deployments work
• How to rotate secrets
• How to add new organizations
• How to recover from a failed deploy

This ensures long-term maintainability.

Required Skills
• DevOps
• Vercel
• Render.com or Railway.app
• CI/CD pipelines
• PostgreSQL connectivity
• Environment & secret management
• DNS configuration
• SSL/HTTPS setup

Nice-to-have:
• Next.js deployment experience
• Multi-environment SaaS experience
You are only setting up the infrastructure.

Project Model
• Fixed price
• Milestones preferred:
1. Backend staging deploy
2. Frontend staging deploy
3. Production setup + hardening
4. Runbook delivery
• Timeline: ~7–10 days depending on experience

How to Apply (Follow These Steps)

1. Short Explanation

Tell me which backend platform you prefer (Render or Railway) and why.

2. Relevant Experience

Share 1–3 SaaS projects where you deployed:
• Vercel frontend
• Render/Railway backend
• Postgres/Supabase

3. Your Plan

Briefly outline how you would structure:
• Staging
• Production
• Domain routing
• Secret management

4. Fixed Price Quote

Provide your total project quote (not hourly).

Disqualifiers
• Generic proposals
• No experience with Vercel/Render/Railway
• No examples of real SaaS deployments
• Proposals that ignore staging vs production separation
• “DevOps teams” or agencies applying for a simple MVP role

If you can set up a clean, secure SaaS infrastructure quickly and reliably, I’d like to hear from you.

I need an experienced AWS cloud architect/DevOps engineer to fix a critical issue with my Node.js application deployment on AWS Elastic Beanstalk.

The Problem:
- Node.js/Express application deploys successfully to AWS Elastic Beanstalk
- Server starts and says "serving on port 5000"
- Application completes initialization successfully
- Process immediately exits with code 0 after initialization completes
- Systemd automatically restarts it, creating an endless restart loop (130+ restarts)
- This causes intermittent 502 errors for users

What Works:
- Same code runs perfectly in Replit environment
- Database connections work (AWS RDS PostgreSQL)
- All routes and middleware initialize successfully
- Server binds to port 5000 correctly

Root Cause:
- After async initializeBackground() function completes, Node.js event loop has no active handles
- Process exits cleanly because it thinks there's no more work to do
- We've tried adding setInterval keepalives in multiple locations but they're not being reached

What I Need:
- Diagnose why the keepalive/setInterval code isn't preventing process exit
- Implement a proper solution to keep the Node.js process alive after initialization
- Ensure the application runs stably without constant restarts
- Document the fix and explain the root cause

Technical Stack:
- Node.js (ES modules)
- Express.js
- AWS Elastic Beanstalk (Node.js platform)
- AWS RDS PostgreSQL
- Systemd service management
- TypeScript/esbuild

Requirements:
- Expert-level AWS Elastic Beanstalk experience
- Deep understanding of Node.js event loop and process lifecycle
- Experience debugging systemd service issues
- Available for immediate start
- Must provide clear documentation of the solution


Budget: $50-$300
Timeline: Need this resolved ASAP - ideally within 24-48 hours

We are in the process of launching our marketing website, which will feature both marketing content and the ability for visitors to purchase subscriptions directly from the website.
The objective is to synchronize web-based transactions purchased from our marketing website with our mobile app backend. The subscriptions will be handled via Stripe (requires to be build from scratch), after a visitor purchase a subscription through the website, their subscription data needs to be synced between website backend (Node.js) the mobile app (Kotlin/Swift) and mobile app backend (Laravel) to ensure the user can access their business account in the mobile app after a purchase is made on the website.

To support this initiative, we are seeking an senior independent dual developer experienced with Node.js and Laravel to collaborate with our native mobile app developer (Kotlin/Swift).

See project summary attached.

Are you an independent dual developer with senior-level experience with both Node.js and Laravel, we appreciate your interest in joining us!

Note, there’s no need to outline your approach to this project in your proposal, as the methodology has already been defined in the project summary, so are the project responsibilities.

• We encourage you to focus on duly explaining why you believe you’re a great fit for this role. We’ll reach out to applicants who are deemed qualified and move forward.
• If you’re shortlisted we discuss the methodology, responsibilities in depth in a tech interview once the NDA is in place, at this juncture pls refrain from soliciting answers to tech queries, this pertains to the application phase not assignment of duties
• Upon execution of the NDA, the project scope will be mutually defined. A fixed-price contract will then be based on our pre-set rates, as specified in the job posting. Proposals that deviate from our pre-set rates Incl. placeholder rates will be rejected.
• Proposals submitted by agencies or Digital Project Acquisition Agents (DPAA), posing as independent developers on this platform, will be rejected.

***Read thoroughly!! ***

If you don’t respond properly your application will automatically be denied. Be sure to include your initial bid with your first response. If you need clarification beyond what’s in this post I will answer so long as you meet the requirements. Be sure to include your initial bid in your response to this job post.

Project Overview

I’m building an MVP for a secure, multi-tenant SaaS platform that allows organizations to upload their internal policies, procedures, and documents, and then query them through a strict, citation-based AI assistant.

This is not a basic “chat with your PDF” project.

I need a senior-level AI/RAG backend engineer who can architect and implement the core intelligence engine:
• Multi-tenant isolation (each organization has its own private index)
• Strict zero-hallucination retrieval
• Structured citation output grounded ONLY in source documents
• Clean, modular backend API for a separate frontend developer

This MVP must be technically correct, stable, and demo-ready.


Scope of Work

You will own the entire backend for the MVP:


1. Document Ingestion Pipeline

You will design and implement a pipeline that:
• Accepts PDF, DOCX, or plain text uploads
• Chunks documents using a custom splitting strategy (sections/headings/etc.)
• Generates embeddings using OpenAI (or equivalent)
• Stores chunks with metadata:
• organization_id
• document_id
• section identifiers
• version/date
• Supports safe re-uploading and re-indexing when documents are updated

Each organization must have its own isolated, searchable vector index.


2. Retrieval + Ranking Layer

Must:
• Query ONLY within the requester’s organization index
• Retrieve relevant policy chunks
• Re-rank by semantic + structural relevance
• Enforce confidence thresholds
• Return “No relevant information found” when nothing is strong enough

No guessing. No speculation.


3. Zero-Hallucination Enforcement

This is the core of the MVP.

You will build logic that:
• Forces every answer to be fully supported by retrieved text
• Implements a validate → correct → regenerate loop
• Removes or replaces unsupported claims
• Provides fallback responses when no supporting policy exists
• Never produces ungrounded LLM output

This must be technically robust and predictable.


4. Structured, Citation-Bound Output

Responses must follow a consistent JSON schema.

5. Multi-Tenant Architecture

You must implement backend isolation such that:
• Policies, embeddings, and metadata are partitioned by organization_id
• No organization can access or query another’s data
• Roles supported:
• Admin (upload/manage documents)
• Standard User (query only)

Security and partitioning must be airtight.


6. Backend Engineering

Expected stack (flexible if justified):
• Node.js + Express OR Python + FastAPI
• Vector DB (pgvector, Supabase Vector, Pinecone, Weaviate, etc.)
• Postgres / Supabase for relational storage
• REST API endpoints, including:
• POST /api/query
• POST /api/upload-document (admin)
• GET /api/list-documents
• DELETE /api/delete-document
• POST /api/auth

Logging must record:
• Query text
• Organization/user identifiers
• Retrieved sources
• Confidence scores


7. Deployment (MVP-Level)

Deploy backend to a simple PaaS such as:
• Render.com
• Railway.app

You must handle:
• Environment variables
• DB connections
• Staging vs production environments
• Staging: dev/testing/demo
• Production: controlled, real-document ingestion (owner-controlled)


8. Handoff & Documentation

Provide:
• README with setup + configuration
• Explanation of ingestion pipeline
• Explanation of retrieval + validation flow
• Instructions for onboarding a new organization
• Clear folder structure + comments on critical logic

The system must be maintainable and extendable.


Required Experience

You should have proven experience with:
• Building real RAG systems (beyond basic tutorials)
• Embeddings, chunking, and vector search
• Retrieval re-ranking
• Zero-hallucination or citation-based LLM pipelines
• Designing secure multi-tenant SaaS backends
• Deploying cloud APIs with environment isolation

If you do not have real-world RAG experience, this project will not be a fit.


Nice-to-Have Experience
• Supabase
• pgvector
• Pinecone / Weaviate
• Experience working with policy/procedure-heavy systems
• Prior work on enterprise knowledge assistants


Project Model
• Fixed-price MVP
• Milestone-based payments
• You work alongside a separate frontend developer
• All platform accounts are owned by me
• You receive limited, scoped access to staging environments only


How to Apply (Please Follow These Steps)

To filter out generic or AI-generated submissions, respond using the format below.

1. Short Written Answers

Answer concisely:
1. How would you design a multi-tenant RAG system where each organization has isolated indexes?
2. How would you enforce zero-hallucination and ensure the LLM only outputs content grounded in retrieved documents?
3. What chunking strategy would you use for long, structured documents (sections, subsections) and why?
4. Which vector DB and backend framework would you choose, and why specifically?

No generic textbook answers — I want your reasoning.


2. Small Technical Exercise (Pseudocode Acceptable)

Provide pseudocode (or code) for a function that:
• Takes organization_id, document_text, and document_id
• Splits text into chunks
• Generates embeddings
• Stores chunks + embeddings + metadata in your chosen vector store

This is not a full implementation — I want to see how you structure the logic.


No slides needed — just talk me through your thought process.


Disqualifiers
• Generic answers copy/pasted from ChatGPT
• No mention of multi-tenant isolation
• No clear zero-hallucination strategy
• Overly vague or academic explanations
• Submitting without following the required application steps


If you have the experience to build this correctly, I look forward to your proposal.

I'm seeking an experienced ETL developer to help with data extraction and loading from database systems into Google Cloud.

Key Tasks:
- Set up and configure Google Cloud environment for ETL processes.
- Extract data from various database systems (specific ones to be confirmed).
- Load extracted data into Google Cloud storage or specified destination.

Ideal Skills and Experience:
- Proficiency in Google Cloud services, especially for ETL.
- Strong experience with database systems, particularly MySQL, PostgreSQL, and Oracle.
- Familiarity with ETL tools and data pipeline development.
- Knowledge of data security and compliance in cloud environments.
- Ability to troubleshoot and optimize ETL processes.

Please provide examples of similar work done and your approach to ensure data integrity during extraction and loading.

Skills: Data Processing, Database Administration, Big Data Sales, Hadoop, Elasticsearch, Data Integration, ETL, Database Management

We are looking for an experienced full-stack or RTC/video engineer to lead the development of a set of advanced video collaboration features for our web platform.

Our application is built on top of Agora with real-time calling and native screen sharing already in place. We are now expanding into a more powerful, interactive collaboration environment with synced playback, drawing tools, custom video UI, and a storage system similar to Google Drive.

This is a substantial, multi-phase build involving real-time media, interactive tooling, and scalable backend infrastructure. We are ready to bring on an engineer who can guide the technical direction and execute the next major version of our product.

Project Scope & Expectations

The engineer we bring on will begin by reviewing our existing architecture, validating the technical requirements, and outlining the recommended implementation plan for the features listed below.

As part of this initial phase, we expect a formal Request for Quote (RFQ) that includes:
-Estimated hours per feature
-Overall timeline for delivery
-Total projected cost (fixed or range)
-Feature-by-feature cost breakdown
-Recommended milestones and phase structure

Once the RFQ is reviewed, the engineer will move into the interview phase. Upon hiring, the engineer will onboard and directly dive into development and delivery of the full feature set.

What You Will Build
1. Collaboration & Playback
-Drag-and-drop video sharing into active calls
-Real-time synchronized video playback (including frame-by-frame controls)
-Custom in-call video player
-Zoom and pan controls
-Keyboard shortcuts / power-user interactions
-Live drawing/annotation with real-time sync
-Ability to play uploaded video files directly inside the call

2. Storage & Content Management
-Google-Drive–style UI and folder system
-Media file uploading, storage, and retrieval
-Integration with AWS S3
-Backend support for user content libraries

3. Infrastructure & Video Processing
-Video processing backend
-Queue system for ingesting, encoding, and preparing video files
-Server-side “ghost participant” recording (Dockerized services)
-Deep integration with Agora call events and media streams

4. Drawing Tools
-Pen tool
-Undo / redo
-Clear annotations
-Real-time visibility for all participants

Tech Stack
Frontend: React (TSX)
Backend: Node.js / TypeScript
Realtime: WebSockets
Conferencing: Agora SDK
Database: PostgreSQL
Storage: AWS S3
Containers: Docker

Ideal Experience
We are looking for someone with experience in:
-Agora, WebRTC, or similar RTC frameworks
-Building collaborative or interactive video tools
-Media pipelines and video processing
-Full-stack TypeScript development
-Scalable backend systems and cloud storage

Applicants with examples of real-time collaboration or video-focused work will be strongly preferred.

To Apply, please include:
-Detailed RFQ (as stated above)
-A brief summary of relevant RTC/video experience
-Your approach to structuring architecture then implementation
-Your availability to begin

We are prepared to move quickly.

Project Overview We are a bootstrapped automation startup building a "Digital Worker" for a highly regulated industry (high-compliance sector). We are looking for a Systems Architect / Founding Engineer to build a secure, vision-driven desktop agent that automates complex data entry workflows in legacy Windows software.

The Core Challenge: We use Windows desktop applications (ERP systems) that have no APIs. We are building a background agent that acts as a human operator: it uses Computer Vision (Local LLMs) to read the screen/documents and Python Automation to click buttons and type data.

Crucial Constraint: Zero Data Retention (ZDR) Because we handle highly sensitive personal data, our architecture must be "Local First." The desktop agent must process all sensitive data in RAM (volatile memory) on the client's machine. No sensitive record data can ever be stored on disk or sent to our cloud.

What You Will Build (The Hybrid Architecture) You will architect and build two distinct components:

1. The Local Desktop Agent (The Robot)

Tech Stack: Python 3.10+, Electron (or Tauri), PyWinAuto / UIAutomation, Ollama (Local Llama 3).

Function: Runs entirely offline (localhost) for data processing. Uses "Computer Use" agents to navigate legacy UIs.

2. The SaaS Control Plane (The Admin Panel)

Tech Stack: React, Node.js/Python, PostgreSQL, AWS/GCP (Serverless).

Function: Manages licensing, fleet health, and "Safe Analytics" (aggregating metadata like "500 records processed" without ever receiving the actual record details).

Responsibilities (Phase 1 MVP Scope) You will not just build a script; you will build a Workflow Engine that executes a strict 12-step pipeline. The MVP must demonstrate the ability to handle this full lifecycle for a single transaction type:

Ingestion & Vision (Steps 1-3): Monitor a local folder for triggers (PDFs/Images); Use Local OCR/Vision to extract raw text from unstructured layouts; Classify the intent (e.g., "New Request" vs "Modification").

Logic & Validation (Steps 4-6): Match extracted data against the legacy ERP database (Fuzzy Matching); Validate rules (e.g., "Do dates match?"); Assign a "Confidence Score" (if greater than99%, proceed).

Human-in-the-Loop (Steps 7-9): If verification fails, the bot must pause and tag the transaction for human review ("Flag/Label"); The bot waits for a human "Resume" signal before continuing.

Execution & Audit (Steps 10-12): If verified, the bot simulates mouse/keyboard input to enter data into the legacy app; Generate a sanitized audit log and archive the source file.

Required Skills

Deep Windows Automation: Experience with pywinauto, comtypes, or Accessibility API to control older Win32 applications.

Local AI Inference: Experience running open-source models (Llama 3, Mistral) locally using Ollama or ONNX to ensure data privacy.

Computer Vision: Ability to identify UI elements and extract text from messy document layouts without relying on cloud APIs.

Secure Architecture: You understand "Zero Trust" and how to design a system that processes sensitive data without logging it.

Full Stack SaaS: Ability to build the web backend (Auth, Stripe, License Keys) that manages the desktop agents.

Why This is a Unique Challenge You aren't just building a web app; you are building a distributed fleet of AI workers. You need to solve hard problems like: "How do we update the Python bot on 500 client machines without breaking their custom configurations?" and "How do we prevent the bot from hallucinating when reading a messy handwritten form?"

To Apply: Please share 1-2 examples of desktop automation projects you have built. Specifically, mention any experience you have with "Computer Use" (AI controlling a mouse/keyboard) or automating applications that do not have an API.

• Have you automated a legacy Windows app with NO API? Which Python libraries (e.g., pywinauto, UIAutomation) did you use, and how did you verify elements reliability?
• How would you run local inference (e.g., Llama 3 via Ollama) to ensure "Zero Data Retention," processing sensitive data in RAM without saving files to disk?
• We process messy document images locally. How would you extract structured data from handwriting/layouts without using Cloud APIs? (e.g., Tesseract vs. LLaVA?)
• How would you architect the Desktop-to-Web connection so the Admin Dashboard receives status updates (e.g., "Success") but NEVER receives the sensitive data?
• If we deploy this agent to 500+ client machines, how would you architect "Over-the-Air" updates to patch the Python code without breaking local configs?

I have a React-based product in active development and now need a dedicated Ruby on Rails engineer to own the server-side layer. The focus is squarely on backend development: designing a clean data model in PostgreSQL, exposing REST or GraphQL endpoints, and wiring everything into our continuous-deployment pipeline so we can ship quickly and iterate often.

Success here demands more than just writing code. I’m counting on you to bring at least two years of professional software-engineering experience, a solid CS (or comparable) background, and a track record of launching user-facing features at scale. You should feel at home in an agile workflow, pushing small, well-tested commits several times a day and collaborating closely with a React front-end team.

While Rails is the core requirement, familiarity with Typescript, GraphQL, and HAML will make integration smoother. If you’ve previously tuned Postgres for performance, even better.

Deliverables
• A production-ready Rails codebase with automated test coverage
• Documented API endpoints that plug cleanly into our React front end
• Deployment configuration (CI/CD) that supports rapid, reliable releases

Let me know about similar projects you’ve shipped, the tooling you prefer, and how you’d approach the first milestone. I’m ready to start as soon as we align on a plan.

Skills: JavaScript, Ruby on Rails, PostgreSQL, Ruby, Git, RESTful API, Continuous Integration, GraphQL

If you're identity is not verified do not apply!

About the Role
We're looking for a Senior Backend Engineer to design, build, and maintain scalable API-driven systems. You'll work across the full backend stack, owning everything from database architecture to API design to production deployment.

What You'll Do
Design and implement RESTful APIs that power client applications
Architect and optimize PostgreSQL databases for performance, scalability, and data integrity
Build and maintain backend services using NestJS and TypeScript
Collaborate with frontend engineers, product, and stakeholders to translate requirements into technical solutions
Establish patterns and best practices for the engineering team
Participate in code reviews, technical planning, and architectural decisions
Mentor junior engineers and contribute to a strong engineering culture
Experience with LLMs and AI/ML systems (embeddings, RAG, prompt engineering, vector databases)
Building AI-powered features or integrating AI APIs into production systems
Experience with message queues (SQS, Redis, RabbitMQ)
Event-driven architecture patterns
Infrastructure as code (Terraform, CDK, CloudFormation

Requirements
5+ years of professional backend development experience
Strong proficiency in TypeScript and Node.js
Deep experience with NestJS (or similar frameworks like Express/Fastify with comparable patterns)
Expertise in PostgreSQL including query optimization, indexing strategies, and schema design
Hands-on experience with TypeORM or similar ORMs (Prisma, Drizzle, Sequelize)
Proven track record designing and building API-driven architectures
Understanding of authentication/authorization patterns (OAuth, JWT, RBAC)
Experience with testing strategies (unit, integration, e2e)
Familiarity with containerization (Docker) and CI/CD pipelines
AWS experience (EC2, RDS, Lambda, ECS, or similar services)