Find Your Next TypeScript Project

Software Engineer – Telehealth SaaS Platform

Remote | Full-time

About Us

We’re building a modern telehealth SaaS platform that powers digital clinics, online pharmacies, and provider networks. Our technology enables healthcare brands to launch, scale, and manage their services; from prescriptions and patient portals to provider workflows and pharmacy logistics; all through a customizable, API-first platform.

About the Role

We're looking for a full-stack Software Engineer who’s passionate about building well-structured, type-safe applications and solving real-world healthcare challenges. You'll work across our SaaS product, helping develop everything from the doctor dashboard and patient portal to backend systems that manage prescriptions, pharmacy coordination, and clinical logic.



Our Stack

Frontend: Next.js, React, Tailwind CSS, Radix UI

Backend: tRPC, Node.js, TypeScript, Prisma, PostgreSQL

Tooling: Turborepo (monorepo), modern CI/CD, Vercel



What You’ll Do

Build and maintain features across our Next.js web apps used by patients, providers, and partners

Develop type-safe APIs with tRPC to manage core business logic, workflows, and provider operations

Design responsive, accessible UI components using Tailwind CSS and Radix UI

Contribute to our monorepo architecture and modular codebase using Turborepo

Optimize performance for data-heavy tables, charts, and real-time updates

Collaborate with product and design to ship features quickly, while keeping quality and security in mind

Participate in code reviews, write tests, and contribute to technical documentation



What We’re Looking For

2+ years of experience working in a modern TypeScript environment

Strong knowledge of React, Next.js, and API architecture

Experience with PostgreSQL and Prisma, or similar ORMs/databases

Familiarity with tRPC, or enthusiasm for strongly typed API patterns

Bonus: Background in healthcare or experience building regulated platforms


Why Join Us

Real impact: Your code powers real telehealth experiences for thousands of patients

Modern developer stack: We invest in DX and developer autonomy

Product-driven culture: Small, fast-moving team with real ownership

Remote-first: Flexible hours, async-friendly, and no micromanagement

Project Overview

We are looking for a talented and reliable Full Stack Developer to join us on an ongoing basis. Our projects involve building scalable web applications, maintaining existing platforms, and delivering high-quality features using modern technologies.

If you’re experienced, detail-oriented, and comfortable taking ownership of tasks, we’d love to collaborate with you.

Responsibilities
- Build and maintain full-stack web applications
- Develop clean, efficient, and reusable code in both frontend and backend
- Integrate APIs, third-party services, and internal tools
- Troubleshoot and debug issues in production and staging environments
- Work with databases (SQL/NoSQL) for schema design and optimization
- Collaborate with our team to translate requirements into technical solutions
- Ensure responsive, performant, and secure applications
- Participate in code reviews and suggest improvements

Required Skills
Frontend:
React.js, Vue.js, or Angular
HTML5, CSS3, Tailwind/Bootstrap
TypeScript / JavaScript
Responsive UI implementation from Figma/Adobe XD

Backend:
Node.js, PHP (Laravel/Symfony), or Python (FastAPI/Django)
REST API development
Authentication & authorization workflows
Microservice architecture (a plus)

Database:
MySQL, PostgreSQL, or MongoDB
Query optimization and data modeling

DevOps / Tools:
Git & GitHub/GitLab
Docker (nice to have)
CI/CD basics
Cloud services (AWS, GCP, or Azure is a plus)

Nice to Have
Experience with Shopify, WordPress, or other CMS
Experience with AI/LLM integrations (OpenAI, etc.)
Understanding of caching layers (Redis)
Performance optimization skills

What We Offer
Long-term collaboration
Fair and timely payments
Flexible working hours
Clear requirements and fast communication
Stable workflow with continuous tasks

Skills: PHP, JavaScript, Python, Node.js, AngularJS, React.js, Full Stack Development, Vue.js, Angular, REST API

We need a Next.js and Node.js expert to work on various enhancements to our current platform. Responsibilities include developing new modules, refactoring old code, managing API integrations, resolving bugs, and ensuring the application runs efficiently across all devices. Experience with authentication, middleware, server-side rendering (SSR), and modern frontend practices is highly preferred. The role requires strong problem-solving skills and the ability to deliver high-quality code.

English Level: B2/C1 required
Overview: Full Stack Developer with strong frontend focus in Vue.js and backend capabilities in NestJS/Node.js. .NET experience is a plus.
Key Responsibilities:
Build complex web interfaces with Vue.js (Composition API, Vuex/Pinia)
Develop backend logic with NestJS and Node.js
Design and integrate REST/GraphQL APIs
Collaborate with dev, QA, and DevOps teams
Required:
3–5+ years Vue.js experience
Professional experience with NestJS, Node.js, TypeScript
API development, microservices, authentication/authorization
Testing (Jest, Cypress) and Git/CI-CD knowledge
Nice to Have:
.NET (C#, ASP.NET Core)
Azure DevOps and pipelines
MS SQL Server, SQL, and NoSQL databases

Project Overview

I want to build a real estate marketplace website for properties in Syria, targeting people inside Syria and Syrians abroad. Users should be able to search, view, and filter properties; owners and brokers can post listings; buyers can contact sellers via internal messaging; and listings can have different verification levels to build trust. The website must be bilingual (Arabic default + English) and fully responsive.

Main Features (MVP)

User Roles

Guest: browse/search, view listing details

Registered User (owner/broker): create/manage listings, chat with buyers

Admin: approve/reject listings, manage users, handle verification requests

Authentication & Profile

Register/login with phone + password

Basic profile (name, phone, WhatsApp, user type, preferred language)

Listings

Add/edit/archive listings (sale/rent/under construction)

Fields: title, description, city, neighborhood, type, area, rooms, bathrooms, floor, furnished, price (SYP/USD), features, images

Status: draft / pending / approved / rejected / archived

Search & Filters

Search by city, neighborhood, listing type

Filters: price range, area, rooms, bathrooms, furnished, property type, verified only

Sorting: newest, price low→high, high→low

Listing Details Page

Image gallery

Price in SYP + USD

Main details + features

Map location (OpenStreetMap is fine)

Verification badge (if verified)

“Contact owner” button → opens chat

Verification System (Trust)

Owner can request verification and upload documents

Admin can review documents and set verification level (C/B/A)

Listing shows “Verified – Level X” badge

Messaging (Chat)

One-to-one chat between buyer and owner per listing

Inbox page + conversation view

Admin Panel

Manage users (block/unblock)

Manage listings (approve/reject)

Manage verification requests (review docs, set level)

Bilingual & RTL

Arabic as default language (RTL)

English as second language (LTR)

All text via translation system (no hard-coded strings)

Preferred Tech Stack (Flexible if you propose better)

Frontend: Next.js (React, TypeScript) + Tailwind CSS

Backend: NestJS (Node.js, TypeScript) + PostgreSQL

ORM: Prisma or TypeORM

Maps: Leaflet + OpenStreetMap

Auth: JWT (access + refresh)

Storage: S3-compatible for images

Deliverables

Clean, well-structured code (frontend + backend)

Database schema + migrations

API documentation (endpoints + example requests)

Basic deployment instructions (how to run in production)

You can add at the end:

Please send:

Your suggested tech stack (if different)

2–3 similar projects you built (marketplaces / real estate / classifieds)

Rough timeline and cost estimate for MVP.

Skills: PHP, JavaScript, Website Design, Graphic Design, HTML, Node.js, React.js, Web Development

I am looking for an experienced full-stack developer to build an MVP SaaS platform called Instant Estimator. This product allows electricians and home-service companies to create simple “instant estimate” forms that their customers can fill out. When a customer completes the form, the system generates a price estimate and automatically creates a lead in a lightweight CRM.

This MVP is straightforward and fully specified. No AI engines, no dynamic website builder, no complex UX - just a clean SaaS CRUD application with deterministic pricing logic.

What You Will Build

1. Authentication & Multi-Tenant Setup

Email/password signup + login
Each company has its own isolated data (multi-tenant architecture)

2. Company Dashboard

Includes:
Home page with basic stats
Leads/CRM page (list + kanban view)
Ability for the company to manually add or import leads (CSV)

3. Estimator Form Builder (Core Feature)

Each company can create up to 3 estimators.

They define:
Questions
Answer options
Price rules (labor hours, materials, modifiers, travel fee)
Pricing logic is 100% deterministic — no AI needed at runtime.

4. Public Estimator Page
A hosted page that:
Loads the company’s estimator config
Displays questions to customers
Calculates price using deterministic rules
Collects customer contact info → creates a lead

5. Embeddable Widget
A lightweight JS snippet that:
Loads a floating button on any website
Opens the estimator in an iframe modal
Works on WordPress, Squarespace, Wix, etc.

6. Stripe Subscription Billing
Monthly subscription
Stripe Checkout + Customer Portal
Activation required before estimator link/widget is available

Tech Stack Requirements

Strong experience with:
React or Next.js
Node.js / Express (or Next.js API routes)
PostgreSQL
Prisma (preferred)
Tailwind CSS
Stripe API
Multi-tenant SaaS experience is a plus

Code Quality Requirements (Important)

The code must be:
Clean, modular, and readable
Structured so AI tools (Bolt, ChatGPT, Copilot) can easily extend it
Written in TypeScript for both frontend and backend
Organized in a predictable, conventional architecture
Simple enough for a single developer to maintain long-term

This is a key requirement because I will continue improving the product using AI-assisted development.

Deliverables
Fully working SaaS MVP deployed on Vercel/Render/AWS
All pages/screens specified in the PRD
Embeddable widget + public estimator page
Deterministic pricing engine
Stripe subscription flow
Documentation for setup and further development

Communication & Workflow
Clear, structured communication
Daily or every-other-day updates
Milestone-based delivery
Continuous review and fast feedback from me
I will provide the full PRD before development begins

We are looking for a React-Native expert to perform a focused set of updates to ensure our existing app builds and runs correctly under the latest iOS technical standards. The project is currently built with React Native 0.75.2, and the required adjustments are primarily on the iOS side with light validation on iOS.

Project Scope

This is a short engagement intended to be completed within a few hours. The work involves reviewing the current build configuration and making the necessary updates to align with the newest Android tooling and runtime expectations.

Responsibilities

- Review and update Android build settings, native configurations, and project structure.
- Implement any required adjustments ensuring the app is compatible with the current Android ecosystem.
- Confirm that the app builds and functions properly on Android devices.
- Validate that recent changes do not introduce issues on iOS.
- Provide a brief technical summary of modifications made.

Required Skills

- Strong, proven experience with React Native.
- Deep understanding of iOS build pipelines, native modules, and packaging behavior.
- Comfortable navigating both Android and iOS folders in a React-Native project.
- Ability to deliver fast, precise updates within a short time frame.

Request for Proposal (RFP) – Re-Architecture and Modernization of SUBER Ride-Hailing & Multi-Service Super App to Cloud-Native Microservices on AWS


SUBER is developing a Canadian ride-hailing and on-demand multi-service "super app" to launch initially in Ontario in 2026, with a roadmap to expand nationally and internationally. The current product baseline is a monolithic that is not suitable for SUBER's long-term scale, agility, compliance, or innovation objectives. SUBER now seeks an experienced AWS partner to deliver a greenfield, cloud-native, event-driven microservices platform hosted on AWS, with Amazon Elastic Kubernetes Service (Amazon EKS) as the primary orchestration layer and a modern DevSecOps toolchain throughout the lifecycle.

The selected partner will design and implement a fully decoupled microservices architecture with strong domain boundaries, domain-owned data stores, and asynchronous event-driven workflows, enabling high scalability, resilience, and independent deployment of services. The target platform must support multi-tenant operation, localized regulatory and tax logic, and flexible support for multiple mobility and on-demand service verticals (rides, deliveries, services marketplace, and future offerings). SUBER requires a robust multi-account AWS foundation, zero-trust security, defense-in-depth at all layers, and compliance with PCI-DSS for payment processing, as well as PIPEDA and GDPR for personal data protection.

Vendors must demonstrate deep practical expertise with Amazon EKS, container security, zero-trust architectures, and modern observability stacks, alongside proven delivery of similar large-scale platforms on AWS. The engagement will span discovery, architecture, build-out, migration, testing, and go-live, culminating in a production-ready platform and a 12‑month hypercare and support period. This RFP defines detailed technical and commercial requirements to allow vendors to provide accurate, comparable proposals within a narrow pricing variance band.




Project Objectives & Current Pain Points
SUBER's strategic objective is to own and operate a differentiated, scalable super app platform rather than relying on a generic monolithic product. The new platform must support rapid feature development, localized differentiation for Canadian markets, and future expansion into additional services and geographies without fundamental architectural rework. The primary goal is to build a robust, cloud-native, microservices-based system on AWS that can handle high concurrency, maintain strict security and compliance, and enable flexible product evolution.

Current pain points with the monolithic codebase include:
Tight coupling of ride-hailing, delivery, wallet, promotions, and admin logic, making changes risky and slow.
Shared database schema with limited isolation, leading to performance bottlenecks, difficult scaling, and complex data migrations.
Limited observability, making it hard to diagnose production incidents or understand behavior under load.
Insufficient security controls and lack of alignment with modern zero-trust, mTLS, and fine-grained authorization patterns recommended for Kubernetes-based architectures on AWS.

Operationally, the monolithic architecture constrains SUBER's ability to:
Scale specific domains (e.g., real-time matching, geospatial search, notifications) independently based on workload characteristics.
Run safe experiments (A/B tests, feature flags) and canary deployments across regions and user cohorts.
Integrate cleanly with multiple third-party providers for maps, payments, messaging, and risk/fraud services.

The new platform must break these constraints by implementing clearly bounded microservices with domain-owned data, asynchronous messaging, and a strong DevSecOps foundation. It should provide a clear separation between mobile clients (passenger, driver/provider, kiosk, web portal), back-end microservices, data analytics, and admin tooling. This re-architecture will position SUBER for sustainable growth, easier compliance, and faster innovation cycles aligned with best practices for large-scale EKS workloads on AWS.




Detailed Scope of Work
The selected vendor will be responsible for end-to-end architecture, design, implementation, and initial operation of a greenfield AWS-native platform, including core services, mobile and web client integrations, DevSecOps tooling, and operational runbooks. The scope covers:

Platform and Microservices
Define and implement a microservices architecture with at least 24 independently deployable services, each owning its data store and exposing well-defined APIs and events.
Design services to follow domain-driven design (DDD) principles, clear bounded contexts, and event-driven integration patterns.
Implement stateless services where possible, with state held in managed AWS data services (e.g., RDS, DynamoDB, or other suitable datastores per microservice needs).

Client Applications
Integrate existing or newly developed mobile apps for:
Implement a responsive, role-based Admin dashboard for operations, support, finance, compliance, and marketing teams.

Core Functional Domains
Ride-hailing flows: user registration, KYC where needed, driver onboarding, vehicle management, trip lifecycle (request, match, accept, start, end, payment).
Deliveries and multi-service marketplace flows: pickups, drop-offs, service booking, catalog and pricing, partner management.
Wallet and payments, loyalty and rewards, promotions, referral programs.
Notifications (push, SMS, email, in-app), support and ticketing, fraud detection, and dispute workflows.

DevSecOps & Operations
Implement CI/CD pipelines, GitOps deployment, infrastructure-as-code, environment strategy (dev, staging, pre-prod, prod), and release management.
Establish monitoring, alerting, logging, SLOs/SLIs, and incident response runbooks for production operations.
Provide operational handover, documentation, and knowledge transfer to SUBER's internal team.

The vendor must work closely with SUBER stakeholders, following agile delivery with fortnightly demos, backlog grooming, and transparent reporting on scope, risks, and issues. The final deliverable is a production-ready platform deployed to AWS with all core ride-hailing and super app capabilities, appropriate non-functional characteristics, and support arrangements in place.




Mandatory AWS Infrastructure & Containerization Requirements
The target platform must be designed and implemented on AWS following a multi-account, security-first foundation aligned with AWS Organizations and Amazon EKS best practices.

AWS Accounts & Organization Structure
Use AWS Organizations with AWS Control Tower (or equivalent Landing Zone) for:
Apply Service Control Policies (SCPs) to enforce guardrails (e.g., restricted regions, restricted root user actions, mandatory encryption).

Networking & VPC Design
Design hub-and-spoke or centralized networking with:

Containerization & Images
All application workloads must run in Docker containers, built via multi-stage Dockerfiles to minimize image size and surface area.
Use non-root containers, distroless or Alpine-based images, and scratch where feasible, with read-only root filesystems and restricted capabilities.
Enforce image signing and verification in the pipelines, and define base images with hardened configurations shared across services.

Container Registry & Image Management
Use Amazon Elastic Container Registry (Amazon ECR) as the primary container registry with:

Orchestration & Compute
Use Amazon Elastic Kubernetes Service (EKS) as the mandatory orchestration platform for microservices.
Where appropriate, use serverless integrations (AWS Lambda) for glue logic, low-frequency jobs, and event processing flows, but EKS remains the primary runtime.

The vendor must provide detailed infrastructure diagrams, Kubernetes cluster layouts (namespaces, ingress, service mesh if applicable), and environment promotion strategies. All infrastructure must be provisioned via Terraform or AWS CDK and stored in version control, with peer review and automated validation.




Detailed Microservices Architecture
SUBER requires a microservices architecture composed of at least 24 domain-aligned services. Each service must:

Own its own datastore (relational, NoSQL, or specialized) with no cross-service database access.
Expose REST and/or gRPC APIs with versioned endpoints and clear contracts.
Publish and consume domain events through the messaging backbone.


Event-Driven Architecture & Messaging
The platform must adopt an event-driven architecture to decouple services, improve scalability, and enable extensibility. Core principles include:

Use Amazon EventBridge as the primary event bus for domain events, organizing buses and rules per domain or environment.
Use Amazon Simple Queue Service (SQS) and Amazon Simple Notification Service (SNS) for reliable queueing and fan-out patterns where EventBridge routing alone is insufficient.
Where high-throughput streaming or ordered event processing is required (e.g., analytics, fraud, telemetry), vendors may propose Amazon MSK (Managed Kafka) as an additional messaging backbone.

Schema Registry and Contract Testing
All events must follow a consistent schema strategy (e.g., JSON with explicit versioning), with a schema registry (e.g., MSK/Schema Registry or custom registry) to manage compatibility and evolution.
Implement consumer-driven contract testing (e.g., Pact) for both synchronous APIs and asynchronous events to prevent breaking changes.
Define clear event naming and domain ownership conventions (e.g., `trip.trip_completed.v1`, `payment.payment_captured.v1`).

Messaging Requirements
Idempotency guarantees for consumers must be designed via event IDs and deduplication logic.
Dead-letter queues and retry policies must be implemented for all critical event consumers, with observability into poison messages and failure patterns.
Security must be enforced at the messaging layer with IAM-based access controls and encryption in transit and at rest (e.g., KMS-managed keys).




DDoS & DoS Protection (L3 to L7) – Detailed Requirements
The SUBER platform must be hardened against volumetric, protocol, and application-layer DDoS/DoS attacks across all exposed surfaces (mobile APIs, web portals, admin interfaces, public webhooks).

AWS Shield Advanced (Mandatory)
Enable AWS Shield Advanced on all internet-facing resources (e.g., CloudFront distributions, Application Load Balancers, Amazon API Gateway endpoints) to provide enhanced detection and protection against L3/L4 and some L7 attacks.
Configure Shield Advanced health-based detection and incident response integration, including contact and escalation paths.

AWS WAF and Rate Limiting
Deploy AWS WAF with:
Integrate WAF with CloudFront and/or ALB, with per-environment policies and logging for security analytics.

API Gateway and Throttling
For any APIs exposed via Amazon API Gateway, configure usage plans, throttling limits, and API keys or OAuth scopes for partner and internal integrations.
Enforce per-client or per-application rate limits to isolate abusive or misconfigured consumers and protect core services.

CloudFront and Origin Shielding
Use Amazon CloudFront as the primary CDN and edge protection layer for web and static assets, with TLS termination and HTTP-to-HTTPS redirection.
Enable CloudFront Origin Shield for appropriate origins to improve cache hit ratio, reduce origin load, and provide an additional buffering layer during traffic spikes.
Configure origin failover (e.g., multi-region backends) where appropriate as part of resiliency strategy.

Network and Application Hardening
Use security groups and NACLs to limit access to backend services; no direct public internet access to EKS nodes or internal services.
Apply authentication, authorization, and input validation at the Gateway layer and within each service to avoid single points of failure.
Implement monitoring, dashboards, and runbooks specifically for DDoS/DoS scenarios, including traffic anomaly detection and automated mitigation triggers.




Security & Compliance Requirements
Security must follow a zero-trust model across users, services, and infrastructure. The platform must be designed for compliance with PCI-DSS for payment flows and data privacy regulations such as PIPEDA and GDPR.

Zero-Trust & Service-to-Service Security
Implement zero-trust principles for Amazon EKS workloads, including strong identity, fine-grained authorization, and microsegmentation.
Enforce mTLS for all service-to-service communication using a service mesh such as Istio or AWS App Mesh, integrated with a robust certificate management solution (e.g., ACM Private CA).
Use pod-level identity via IRSA to grant least-privilege access to AWS services per microservice.

Authentication & Authorization
Use Amazon Cognito as the primary identity provider for mobile/web clients, supporting OIDC and social identity providers where needed.
Implement role-based access control (RBAC) for admin and operational users, with granular permissions per role and auditable changes.
Use JWT or OAuth2/OIDC tokens for client and service access, with short-lived tokens and refresh flows.

Key Management, Secrets, and Configuration
Use AWS Key Management Service (KMS) for encryption keys covering data-at-rest in RDS, DynamoDB, S3, and messaging systems.
Store all application secrets (database credentials, API keys, third-party credentials) in AWS Secrets Manager; use AWS Systems Manager Parameter Store for non-secret configuration.
Enforce rotation policies for keys and secrets, integrated with CI/CD workflows.

Compliance: PCI-DSS, PIPEDA, GDPR
Segregate PCI-scoped components (e.g., payment service, card data handling) into isolated network and Kubernetes namespaces with tightened controls.
Ensure that any cardholder data is tokenized or delegated to third-party payment providers as much as practical, minimizing PCI scope.
For PIPEDA and GDPR:

Security Testing and Vulnerability Management
Integrate static and dynamic application security testing (SAST/DAST) into CI/CD pipelines, with thresholds for failing builds.
Enable vulnerability scanning for container images in Amazon ECR and third-party dependencies, with remediation workflows.
Include regular penetration testing and periodic third-party security assessments.
Define scope and governance for a bug bounty program, including reporting and triage processes.




Scalability, Performance & Resilience
The SUBER platform must support at least 100,000 concurrent users and 10,000 concurrent active trips/deliveries, with the ability to scale further as adoption grows. Performance and resilience must be built into the architecture from the outset.

Scaling and Autoscaling
Use Kubernetes Horizontal Pod Autoscaler (HPA) for microservices based on CPU, memory, and custom application metrics (e.g., queue length, request latency).
Use Cluster Autoscaler and/or Karpenter for dynamic scaling of EKS worker nodes or Fargate capacity based on pending pods and resource utilization.
Separate high-intensity workloads (e.g., ride matching, geospatial updates, notifications) into dedicated node groups or Fargate profiles.

High Availability and Multi-AZ
Deploy production EKS clusters and databases across at least three Availability Zones within a region.
Use Multi-AZ RDS deployments and, where appropriate, DynamoDB global tables or replicas for critical state.
Ensure all stateless services are deployed with multiple replicas and pod disruption budgets to maintain service availability during maintenance.

Disaster Recovery & Cross-Region Strategy
Implement a cross-region disaster recovery strategy with at least a pilot-light environment in a secondary AWS region, including replicated critical data and infrastructure templates.
Achieve a Recovery Time Objective (RTO) of less than 4 hours and a Recovery Point Objective (RPO) of less than 5 minutes for critical services and data, using database replication, log shipping, and cross-region backups.
Document and test DR runbooks, including failover, DNS cutover, and validation steps, at least annually.

Performance Engineering
Implement load testing (k6, Artillery, or equivalent) to validate performance targets and identify bottlenecks before production.
Use caching strategies (e.g., Redis/ElastiCache, CloudFront) and efficient data access patterns to reduce latency.
Monitor end-to-end user experience metrics (e.g., p95/p99 latency) and define SLOs/SLIs for key journeys (request ride, start trip, complete payment), with alerts on SLO violations.




Observability & Monitoring Stack
The platform must provide full-stack observability across infrastructure, Kubernetes, microservices, and user journeys.

Use Amazon CloudWatch for metrics, logs, and alarms at the infrastructure and EKS levels, including cluster health, node utilization, and autoscaler behavior.
Use AWS X-Ray (and/or OpenTelemetry tracing) for distributed tracing of microservice calls, particularly across critical flows (login, trip lifecycle, payment).
Deploy Prometheus and Grafana as EKS add-ons for fine-grained application and Kubernetes metrics, service-level dashboards, and capacity planning.
Implement OpenTelemetry SDKs/agents in microservices to standardize metrics, logs, and traces, exported to Prometheus, X-Ray, and/or a centralized observability backend.
Implement centralized logging using Amazon OpenSearch Service (or equivalent), with structured logs, correlation IDs, and retention policies appropriate for operational and compliance needs.
Provide ready-to-use dashboards for:




CI/CD & IaC Requirements
The delivery workflow must follow modern GitOps and Infrastructure-as-Code practices.

Use Git-based workflows (feature branches, pull requests, code review) as the single source of truth for application and infrastructure code.
Implement GitOps for Kubernetes deployments using Argo CD or Flux, with declarative manifests (Helm or Kustomize) and environment-specific overlays.
Use Terraform or AWS CDK (TypeScript) for all AWS infrastructure, including VPCs, EKS clusters, RDS, IAM, and networking; store IaC in dedicated repositories with automated plan/apply pipelines.
Implement CI pipelines using AWS CodePipeline and CodeBuild (or compatible alternatives) for:
Enforce quality gates (tests, security scans, code coverage thresholds) and require manual approvals for promotion to production.
Implement blue/green or canary deployment strategies for key services to reduce deployment risk.




Third-Party Integrations (Mandatory)
The platform must integrate with the following third-party services (or approved equivalents), abstracted behind microservices to allow future provider changes:

Maps & Geolocation
Payments
Push Notifications
SMS/VoIP & Call Masking

All third-party credentials must be managed through AWS Secrets Manager and integrated into CI/CD and runtime via secure mechanisms. The architecture must allow easy substitution or addition of providers per region or regulatory requirements.




Data Migration Strategy from Existing Monolith
SUBER requires a carefully planned data migration strategy from the existing monolith to the new microservices platform, minimizing downtime and preserving data integrity.

Discovery and Mapping
Conduct a detailed data discovery phase to map existing database schemas and key entities (users, drivers, vehicles, trips, payments, promotions) to the new microservice-owned data models.
Identify data quality issues, required transformations, and archival requirements.

Parallel Run and Dual-Write
Implement a parallel run period where both the monolith and the new microservices platform operate concurrently for selected flows (e.g., new users, test regions).
Use dual-write patterns where feasible: new operations write to both the monolith and microservices data stores, with reconciliation jobs to detect and resolve inconsistencies.
Ensure idempotent write operations and robust conflict resolution strategies.

Bulk Migration & Incremental Sync
Perform initial bulk data export from the monolith into staging areas (e.g., S3), transform and validate data, then import into microservice databases.
Implement incremental synchronization pipelines (e.g., via change data capture or scheduled jobs) to keep datasets in sync until cutover.

Cutover & Downtime Management
Define a detailed cutover runbook with:
Aim for zero downtime; if unavoidable, ensure downtime is less than 1 hour and scheduled during low-usage periods with clear user communication.
Post-cutover, run validation checks and reconciliation reports to confirm data integrity and functional correctness.

The vendor must provide tooling, scripts, and documentation to allow repeatable migration processes for additional regions and environments.




Testing Requirements
Quality assurance must be embedded across all phases, with strong emphasis on automation.

**Contract Testing**
**Functional and Integration Testing**
**Performance and Load Testing**
**Chaos Engineering & Resilience Testing**
**Security Testing**




Project Phases & Timeline Expectations
SUBER expects the vendor to propose a detailed project plan aligned with the following high-level phases. Total expected duration is 9–11 months to production go-live.

1. Phase 0: Discovery & Architecture (4 weeks)
2. Phase 1: Foundation (Auth, User, Notification, Geospatial) – 10 weeks
3. Phase 2: Ride-Hailing MVP – 10 weeks
4. Phase 3: Deliveries & On-Demand Services – 8 weeks
5. Phase 4: Unique Features (Lottery, Support Fund, Recording) – 6 weeks
6. Phase 5: Admin, Analytics, Launch – 6 weeks

Vendors must provide a detailed Gantt or equivalent schedule, resource plan, and risk management strategy.




Vendor Experience & Evaluation Criteria
SUBER will evaluate vendors based on technical capability, relevant experience, delivery approach, and commercial terms.

Mandatory Experience
Demonstrated delivery (design, build, and launch) of at least two ride-hailing, logistics, or similar high-scale mobility platforms built on AWS, with microservices and Amazon EKS as the core orchestration layer.
Proven experience implementing zero-trust and mTLS-secured service meshes on EKS for production workloads.
Demonstrated experience with PCI-DSS-aligned architectures and PIPEDA/GDPR-relevant privacy controls.

Preferred Profile
Canadian or North American headquartered teams, or teams with strong presence and references in these regions.
Strong bench of AWS-certified professionals (Solutions Architect Professional, DevOps Engineer Professional, Security Specialty, etc.).
Existing partnership level with AWS (Advanced or Premier) and evidence of collaboration on similar reference architectures.

Evaluation Dimensions
Technical solution quality, alignment with this RFP, and extensibility.
Security and compliance posture and demonstrated best practices.
Experience and references in similar domains.
Delivery methodology, governance, and communication approach.
Total cost of ownership and pricing structure.
Quality of proposed team (roles, seniority, time allocation).




Commercial Requirements & Response Format
SUBER prefers a fixed-price commercial model with clearly defined milestones and deliverables, but will consider time-and-materials proposals where risk sharing and budget caps are well articulated.

Pricing Structure
Separate pricing for:
Clearly specify assumptions, exclusions, and third-party licensing costs (if any).

Response Format
Vendors must include at minimum:

Executive summary and understanding of SUBER's needs.
Proposed architecture and microservices design, highlighting deviations or improvements relative to this RFP.
Detailed project plan, milestones, and resourcing.
Security, compliance, and DevSecOps approach.
References and case studies for similar AWS EKS-based platforms.
Commercial proposal with pricing breakdown and payment milestones.

Submission Instructions
Proposals must be submitted in electronic format (PDF) by the specified deadline (to be provided separately by SUBER).
Responses must not exceed a reasonable length while fully addressing all sections of this RFP.

Biztree is seeking a talented Full-Stack Developer to join our team and build high-quality, scalable web applications.

Responsibilities
Design and develop full-stack (MERN) enterprise applications in alignment with business requirements.
Collaborate directly with clients to capture, clarify, and document business and functional needs.
Propose, present, and defend technical solution approaches, providing architectural and engineering guidance.
Deliver innovative solutions to address complex business and technical challenges.
Stay updated on emerging technologies and industry trends to enhance application quality and engineering efficiency.
Build responsive, high-quality front-end components using React and modern JavaScript frameworks.
Develop scalable back-end services with Node.js, TypeScript, GraphQL, and Express.
Implement solutions using serverless and Function-as-a-Service (FaaS) architectures such as Azure Functions.

Required
Minimum 1 year of professional experience as a Full-Stack (MERN) Developer/Engineer
Hands-on experience developing and deploying applications in public cloud environments.
Proven ability to build responsive front-end applications with React or Angular.
Back-end development skills using Node.js, TypeScript, GraphQL, and Express.
Proficiency in Git/Bitbucket for version control.
Familiarity with RESTful APIs and microservices architectures.

Benefits
Flexible working hours
Mentorship. You will be mentored by seasoned senior developers.

Biztree

Description

I’m looking to establish a long-term collaboration with an experienced Tech Sourcer/Recruiter who can help identify and engage strong technical candidates for various roles. You will work directly with me, and you will not contact clients. Assignments vary, but typically involve senior engineering profiles within modern backend, cloud, data, DevOps or identity/security domains.

What you will be sourcing

Profiles may include:

Senior backend engineers
Cloud/DevOps engineers
Identity & Access Management specialists
Fullstack engineers
Security engineers
(Exact specs will be provided per assignment.)

Typical technical areas you should be comfortable sourcing within:

Java, C#, Python, Go
Cloud (AWS, Azure, GCP)
Docker, Kubernetes, Linux
Identity Management (AD, LDAP, RBAC, ABAC, SCIM, OIDC, SAML)
Modern frontend (React, TypeScript)

Your responsibilities

Identify, engage and qualify suitable candidates
Run a short initial screening call
Deliver structured candidate summaries with clear skill matching
Only submit unique candidates (no CVs scraped from public job ads)

Compensation model
Success fee only
You are paid per hired candidate
No upfront or hourly payments
Fee level discussed in private messages

What I expect from you
Proven track record in tech sourcing or tech recruitment
Strong understanding of engineering roles and terminology
Fast, clear communication

If you’re interested, please share a short intro about your experience and sourcing approach.

• How do you verify seniority in engineering candidates? Give concrete examples.
• What sourcing channels do you use for hard-to-find technical roles?

Title: Python Engineer for UK Planning Portal Integrations (Scraping + APIs)

Summary
I am building an AI-assisted architectural feasibility platform for UK planning. I already have a Next.js frontend and a Node.js backend in place, and I am looking for a Python engineer to build the “planning data” service layer.

The goal is to, on demand, fetch recent planning applications and decisions around a site from local authority planning portals (and national APIs where available), and expose that as a clean JSON API that the Node backend can call.

What you’ll be working on first

Start with one local authority (for example East Suffolk or a similar council) and:

Analyse their public planning search portal.

Implement a Python-based adapter that can:

search for applications within a date range (e.g. last 5 years) and optionally a postcode / map area,

parse results (ref, address, description, decision, dates, URLs),

fetch details / decision notices for selected applications.

Wrap this in a small HTTP API (Flask/FastAPI/etc.), for example:

GET /planning/search?lpa=east_suffolk&from=2020-01-01&to=2025-01-01&lat=...&lng=...&radius=800

GET /planning/application?lpa=east_suffolk&ref=DC/21/1234/FUL
and return normalised JSON.

Add basic caching so repeated queries for the same area/time window do not constantly hit the council site.

Work with my Node.js dev to agree the JSON schemas and error handling so the integration is clean.

Longer-term vision (if we work well together)

Extend the same pattern to multiple LPAs, preferably by building reusable adapters per portal type (e.g. Idox, Uniform, etc.).

Integrate national sources where available (e.g. planning.data.gov.uk) so we only scrape when necessary.

Gradually grow coverage across the UK, with sensible rate limiting and monitoring.

Requirements

Strong Python experience, especially with:

HTTP requests, HTML parsing (Requests, BeautifulSoup, or Playwright/Selenium when needed)

building small REST APIs (Flask / FastAPI / similar)

Real-world experience scraping or integrating with messy third-party sites

Comfortable designing resilient scrapers that handle pagination, sessions, and errors gracefully

Familiarity with basic data modelling and caching (e.g. Redis, simple SQL or file-based stores)

Ability to write clear, maintainable code and documentation

Nice to have

Experience with UK planning portals (Idox, Uniform, etc.)

Experience working with Node/TypeScript teams

Understanding of good citizenship around scraping (respecting robots.txt, rate limiting, etc.)

Engagement

Initial test milestone: build the first working LPA adapter + API.

If successful, extend to more LPAs over time.

I expect this to be a part-time engagement over several months.

When you apply, please:

Share 1–2 examples of web scraping projects or third-party integrations you’ve done in Python (ideally with live URLs or repos).

Briefly describe how you would approach building a robust adapter for a planning portal that uses HTML forms, paging, and document links.

Thanks,
Tom

I’m looking for an experienced React Native + Expo developer to build the first version of a self-guided GPS walking tour app called Walk Charleston Co. The app will allow users to browse tours, purchase them, download the route/audio, and follow the tour with GPS-triggered audio narration at specific stops.

This project is ideal for a developer who has experience with maps, GPS, audio playback, and mobile-friendly UI/UX. The backend will be lightweight, and we will scale features over time.

Project Overview

Walk Charleston Co is a premium self-guided walking tour experience launching in Charleston, South Carolina.
The app needs to deliver:

Smooth GPS navigation

Automatic stop detection

High-quality audio playback

Offline availability

Simple purchase flow

This is an MVP build, but the app should be well-architected for future enhancements, including AI features and additional cities.

Core Features (Phase 1 / MVP)
1. Tour Browsing

List of tours (title, image, description, price, duration, distance)

Tour detail page with map preview

2. Map + GPS Navigation

Full-screen map showing:

User’s real-time location

Tour path (GeoJSON)

Numbered stop markers

Background GPS tracking

Proximity triggers:

When user is near a stop → prompt to play audio

3. Audio Playback

Each stop has an MP3 narration file

Player controls:

Play / Pause

Rewind 15 seconds

Progress bar

Ability to download tour audio for offline use

4. User Accounts + Purchases

Basic authentication (email/password or OAuth)

Purchase flow via:

Apple/Google In-App Purchases or Stripe (to be finalized)

Backend must track which tours a user owns

5. Offline Mode

Download all tour assets (route, audio, images) for offline access

App must continue working without stable signal

Tech Requirements

Frontend (you build):

React Native + Expo

React Navigation

react-native-maps

Expo Location

Expo AV for audio

State management (Zustand or Redux)

Backend (can be you or a separate backend developer):

Node.js + TypeScript

PostgreSQL (Supabase or Neon recommended)

Storage for audio files (Supabase Storage or S3)

REST API for tours, stops, authentication, and tour access

Ability to deploy on Vercel, Render, or AWS

If you can build both mobile + backend, even better — but mobile is the priority.

What I Will Provide

Tour content (scripts, stop descriptions, audio)

Route geometry (GeoJSON)

Branding assets

Wireframes (or collaborate with you to create them)

TestFlight & Android testing access

Project Phases
Phase 1 – MVP (This Contract)

Core app experience with one or two tours

GPS-triggered stops

Audio playback + offline downloads

Purchase flow

Clean, polished UI/UX

Deployment-ready builds for App Store / Play Store submission

Phase 2 – Admin Dashboard (Optional future work)

Web dashboard to manage tours, stops, and audio uploads

Phase 3 – AI Tools (Future Work)

AI-assisted script editing

AI-generated narration

In-app “Ask Your Guide” chat assistant

Ideal Candidate

Strong experience with React Native + Expo

Has built apps with:

GPS tracking

Map integrations

Offline storage

Audio playback

Comfortable working with a Node.js backend (or coordinating with backend dev)

Understands clean architecture and modular code

Excellent communicator, proactive, and can work independently

Deliverables

Complete MVP codebase (React Native + backend endpoints)

TestFlight + Android internal testing builds

Clean, documented code

Basic README for local development

Light analytics (optional)

To Apply

Please send:

Short intro

Portfolio links to similar apps (GPS, maps, audio, React Native projects)

Estimated timeline and budget range for MVP

Note if you can also build the backend

Your preferred working hours and communication style

Hiring: Freelance Next.Js Developer (One-Time Project)
Project Type: One-time website development
Start Date: Immediate
We are looking for a skilled Freelance Next.Js Developer to build a complete website for our project. This is a one-time job with clear deliverables and a defined timeline. If you have strong front-end skills and can deliver high-quality work on time, we’d like to work with you.

🔧 Project Requirements
• Build a modern, responsive website (5–10 pages).
• Develop using Next.js.
• Convert provided UI/UX designs (Figma or sketches) into clean and functional pages.
• Integrate Restful backend/API
• Ensure fast loading, SEO-friendly structure, and mobile optimization.
• Connect forms (contact, lead forms, etc.) to backend by providing CMS.
• Support deployment (Vercel, Netlify, or hosting provider).

🎯 Ideal Candidate
• Strong experience in Next.js.
• Can deliver full website builds independently.
• Good eye for UI/UX and attention to detail.
• Ability to meet deadlines and provide regular updates.
• Must share previous project links or portfolio.

⏱️ Project Duration
• Expected completion: 1–3 weeks, depending on complexity.
• Milestone-based delivery preferred.

💼 Deliverables
• Fully functional website
• Clean and documented source code
• Deployment and handover
• Basic training

Our fast-growing SaaS product automates business workflows, and the next release centres on fresh functionality rather than patching old code. I need to add two categories of integrations:

• Social-media APIs (e.g., Facebook, LinkedIn, X/Twitter)
• External third-party data sources relevant to marketing and analytics

The work spans the full stack. On the back-end you’ll stand up robust, well-documented endpoints, manage auth flows (OAuth 2.0, webhooks, rate-limit handling), and ensure data is normalised for our existing micro-service architecture. On the front-end you’ll surface the new data in a React-based dashboard so users can trigger automations without leaving the app.

Acceptance criteria
• Successful OAuth connection and token refresh for each provider
• Real-time or scheduled data sync displayed in our UI without blocking other features
• Clean, unit-tested code that fits our current TypeScript/Node pipeline and CI suite
• Swagger/OpenAPI docs updated so internal teams can extend the endpoints easily

Access to our GitHub repo, staging environment, and API keys will be provided after kickoff. Deliverables are pull requests ready for code review and a short hand-off walkthrough video.

Skills: PHP, C# Programming, Software Architecture, Node.js, AngularJS, React.js, OAuth, API Development

You must be available to work full time on this project. Be able to utilize AI coding tools like cursor, etc to make development faster. Think outside the box and clear communication. Available to start immediately and work weekends. Product needs to be ready in a month.

Project Overview
Building an MVP for a B2B SaaS platform that integrates with enterprise communication tools and uses AI for data processing and automation.

Technical Requirements
Backend:

REST API development
Third-party API integrations (webhooks, OAuth)
Database design and implementation
Background job/queue processing
Email automation

Frontend:

Modern responsive web application
Dashboard with data visualization
Admin configuration interface

Infrastructure:

Cloud deployment (your recommendation)
CI/CD setup
Basic monitoring


Required Skills

5+ years full-stack development
Node.js/TypeScript
React,
PostgreSQL or similar
API integrations experience
Cloud platform deployment (AWS, GCP, Railway, Render)
Background job systems

Bonus:

Slack/Teams API experience
AI/LLM API integration
B2B SaaS projects
Email delivery systems (SendGrid, SES)


Deliverables

Working MVP application
Deployed to production
Source code with documentation
2 weeks post-launch support

I move quickly with low-code and AI-assisted generators, but every project eventually hits a point where I need clean, hand-written React Native code to push past the limits of those tools. That’s the gap you’ll fill.

The workflow is straightforward: I’ll share a repo that already contains the auto-generated baseline. You’ll step in to build the custom bits—anything from bespoke UI components and native-module bridges to deeper state-management or performance fixes the generators can’t handle. We’ll collaborate through GitHub pull requests, Slack for day-to-day questions, and brief video check-ins to unblock larger architectural decisions.

Your deliverables will be small, well-scoped feature branches that merge cleanly, ship with TypeScript types, and include basic unit tests where practical. I’m platform-agnostic; some apps target iOS, others Android, many both, so familiarity with platform-specific quirks (Xcode projects, Gradle configs, native permissions) is a plus.

If writing elegant React Native code, integrating tricky third-party SDKs, and squeezing extra polish out of animations excites you, let’s talk.

Skills: React.js, React Native, GitHub

# Job Opportunity: Front End Software Engineer

Front-End Developer (React & AngularJS) – Job Description
Overview

We are seeking a skilled Front-End Developer with strong experience in React and AngularJS to join our development team. The ideal candidate has a deep understanding of modern front-end architecture, UI/UX best practices, and hands-on experience working with video streaming technologies, both locally hosted and cloud-based. You will collaborate with cross-functional teams to build high-performance, scalable, and user-friendly interfaces for our applications.

Key Responsibilities

Develop, maintain, and optimize front-end applications using React and AngularJS.

Design and implement responsive, intuitive user interfaces that align with product requirements.

Work with backend teams to integrate RESTful APIs, WebSockets, and other data services.

Implement and manage video streaming solutions, supporting both local servers and cloud platforms (e.g., AWS, GCP, Azure).

Optimize video playback performance, buffering logic, and media handling across devices and browsers.

Troubleshoot and debug front-end issues, ensuring smooth performance and reliability.

Collaborate with UX/UI designers to translate wireframes and prototypes into functional code.

Maintain code quality through best practices, testing, and documentation.

Stay up to date with emerging trends and technologies in front-end development, streaming, and cloud services.

Required Qualifications

Strong proficiency in JavaScript, TypeScript, HTML5, and CSS3.

Hands-on experience building production applications using:

React (hooks, state management, component architecture)

AngularJS (legacy systems maintenance, migrations)

Experience with video streaming technologies, such as:
HLS, DASH, WebRTC, RTMP

Media players (Video.js, Shaka Player, JW Player, etc.)

Encoding, transcoding, and video pipeline workflows

Experience working with cloud platforms for media delivery (AWS Media Services, CloudFront, Azure Media Services, GCP Media, etc.).

Familiarity with Git, CI/CD pipelines, and agile development processes.

Experience with performance optimization, accessibility, and cross-browser compatibility.

Soft Skills

Strong problem-solving and analytical thinking.
Excellent communication and teamwork abilities.
Attention to detail and commitment to high-quality work.
Ability to thrive in a fast-paced, evolving environment.

Nobai Finance – Full Technical Specification for Development Quotes

Comprehensive Scope – Existing Features + Upcoming Modules

1. Project Purpose

Nobai Finance is a cloud-based platform designed to digitalize the mortgage process end-to-end.
The system must enable:

Client onboarding

Document submission and validation

Case management for internal staff

Automated notifications via email and WhatsApp

AI-powered document processing

Lead and pipeline management

Commission forecasting

The platform must operate as a secure, scalable SaaS with role-based access and deep automation.

2. User Roles
2.1 Client

Creates a mortgage application

Uploads required documents

Tracks status and receives notifications

Views progress and next steps

2.2 Internal Staff

Reviews documents

Manages the mortgage pipeline

Communicates with clients

Uploads internal deed-stage documents

Oversees commission forecasting

2.3 External Partner

Limited access for deed-stage document handling

Restricted permissions via role management

3. Technology Stack Requirements

Agencies may propose alternatives, but quotes must reflect the complexity of the following architecture.

Frontend

React plus TypeScript

Vite

React Router

React Query for server state

TailwindCSS

shadcn ui plus Radix UI

React Hook Form plus Zod

Framer Motion

File upload handling for mobile and desktop

Real-time notifications using WebSockets or Supabase Realtime

Backend and Infrastructure

Supabase as primary backend

PostgreSQL

Supabase Auth

Supabase Storage

Supabase Edge Functions written in TypeScript

Supabase Realtime

Full Row Level Security

Notification Providers

WhatsApp Business API via BSP

Email provider such as Resend or SendGrid

AI Components

OCR plus LLM processing for document classification and extraction

Bank FINE PDF parsing

4. Functional Modules

Full feature set including current implementation and planned expansions.

MODULE A – Client Portal
A1. Client Onboarding

Multi-step form capturing personal, employment, financial, and property data

Automatic creation of application record

Role assignment and secure login

A2. Document Checklist System

Dynamic checklist based on client profile

Document status flow
Pending → Uploaded → AI Processing → Accepted or Rejected

Upload support
PDF, JPG, PNG, HEIC, mobile camera

Storage path pattern
applicationId, docType_kind_timestamp.ext

A3. AI Document Processing

After upload, the system performs

OCR

Classification

Error detection

Data extraction

AI output updates
documents.ai_status and documents.ai_payload

Statuses include
pending, processing, parsed, needs review, rejected

A4. Client Dashboard

Progress bar

Required documents overview

Application status Docs → Analysis → Approval → Deed

Real-time in-app notifications

Document viewer

MODULE B – Internal Operations Console
B1. Application Management

Table view of all applications

Filters by status, broker, date, country

Application detail pages with
client info, documents, notes, audit log

B2. Document Review System

PDF and image previews

AI extraction displayed

Accept or Reject actions

Status updates trigger notifications and logs

B3. Staff and Role Handling

Auto-assignment rules

Permissions for
Admin
Broker
Assistant
External Partner

B4. Activity Logging

Status changes

Document uploads

Notifications sent

Notes added

MODULE C – Broker Backoffice

The Cockpit

C1. Dual Pipeline System
Lead Pipeline Kanban

Columns
New → Contacted → Qualified
Features include
Lead decay logic
Notes per lead
Tags and source tracking

Mortgage Pipeline Kanban

Columns
Docs → Analysis → Approval → Deed
Drag-and-drop updates application status
Triggers fire notifications

C2. AI Smart Import – Bank FINE Reader

Process
Upload PDF
OCR and LLM extraction
Extract Spread, TAEG, MTIC, monthly payment, and bank metadata
Auto-fill comparison table
Target performance under four seconds

C3. Lead to Application Conversion

One-click conversion

Creates application

Creates and links client user profile

Sends invitation email

Prevents duplicates

C4. Commission Forecasting

Real-time dashboards for
Current Month

Realized commission

Expected commission

Future Pipeline

Weighted forecasts
Docs 20 percent
Analysis 50 percent
Approval 80 percent

Per-application commission structure with percentages and fixed fees

MODULE D – Automation and Notification Engine
D1. Trigger-Based Notification System

Triggers detect status changes in applications table
Notifications created in notifications table with
channel, kind, status, and payload

Examples
approved → WhatsApp template pedido_aprovado
proposal_ready → Email and WhatsApp proposta_enviada
finalized → Email

D2. WhatsApp Integration

Integration with Meta BSP providers

Templates such as
welcome
docs received
approval
proposal
deed future

Fallback to email when WhatsApp fails

D3. Real-Time In-App Notifications

Notification bell for clients and staff

WebSocket or Supabase Realtime subscription

Instant delivery

Read and unread state

MODULE E – AI Document Intelligence Layer

Includes

Document type classification

Integrity checks for quality and completeness

Data extraction from IRS, payslips, bank statements

AI processing pipeline with statuses
pending, processing, parsed, needs review, rejected

MODULE F – Security and Compliance
F1. Row Level Security

Strict RLS for
applications
documents
notifications
users

F2. Storage Policies

Only authenticated users

Access only to documents tied to user applications

F3. Data Protection

Sensitive information encrypted at rest

Audit logs for compliance

F4. Activity Logging

Timestamps for all critical operations

7. Non-Functional Requirements
Performance

Fast document upload

AI processing under six seconds

Mobile-first experience

Reliability

No silent notification failures

AI errors logged visible in dashboard

Scalability

Capable of supporting
10 thousand clients
500 thousand documents
100 brokers

Maintainability

Modular architecture

Clear separation of concerns

Complete documentation

8. Deliverables Expected from Agency

Agencies must quote for the following:

Frontend development

Backend and API development

Supabase integration and configuration

AI integration and edge functions

WhatsApp and email notification systems

Pipelines and backoffice dashboards

Security including RLS and storage policies

Testing and QA

Deployment and developer handover

Optional mobile app wrapper

We are seeking a skilled Full Stack Developer with expertise in TypeScript to build small custom web applications. The role involves implementing frontend, backend, and component logic according to our coding conventions. This initial project is a test project of approximately 20 hours, with the potential for long-term collaboration.

Senior Shopify Developer: Custom App Development for monthly quantity limits.

We are seeking an Expert Senior Shopify Developer to architect and implement a critical custom solution for our store. This project requires advanced skills in full-stack development within the Shopify ecosystem.

💻 Required Technical Stack
Candidates must demonstrate expert proficiency in the following technologies:

Custom App Backend: Expert experience building production-grade Custom Shopify Applications using a reliable backend framework (Node.js).

Shopify APIs & Webhooks: Mastery of the Admin API (GraphQL), Storefront API, and setting up and managing Shopify Webhooks for real-time event processing.

Database: Experience designing and managing a persistent, external data store (PostgreSQL, or similar) for custom application logic and data.

Frontend Integration: JavaScript (ES6+) for validation logic, and proficiency with Liquid and App Embed Blocks to inject client-side functionality and connect to the custom backend.

Architecture: Proven ability to implement scalable logic, reliable data synchronization, and security best practices.

🛠️ Project Scope Summary
Goal of the project is implement an App that tracks a customers monthly purchased quantity and enforces specific quantity rules across products.

Custom Logic Backend: Building the core application to house quantity rules and data models.

Middleware/Enforcement Layer: Implementing a mechanism to enforce custom logic directly on the storefront (e.g., cart) via an App Embed.

Data Synchronization: Utilizing Shopify Webhooks to ensure continuous and reliable tracking of monthly order data (e.g., order events, customer history) in the external database.

We're building a competitive analysis platform

Tech Stack

- Backend: Node.js, TypeScript
- Database: PostgreSQL (Azure), Prisma ORM
- Frontend: Next.js 15, React, Tailwind CSS
- Infrastructure: Docker, Azure App Service, GitHub Actions CI/CD
- AI Integration: Claude API, MCP servers, autonomous agents

What You'll Work On

- Maintain and extend CLI tools (28+ database commands)
- Build new features for the Next.js web interface
- Support Docker containerization and deployment pipeline
- Work with AI agent workflows for automated research
- Database schema design and migrations
- API development and integrations

Required Skills

- Strong Node.js and TypeScript experience
- Prisma ORM proficiency
- PostgreSQL database design
- Docker and containerization
- Next.js/React for frontend work
- Git workflow (GitHub)

Nice to Have

- Experience with AI/LLM integrations
- Azure cloud services
- Capital markets or fintech domain knowledge
- Understanding of MCP (Model Context Protocol)

Work Style

- Async communication (flexible timezone)
- Well-documented codebase with clear instructions
- Work alongside AI tools (Claude Code)
- Code review and quality focus

L’audit comprend :
• Analyse complète du backend
• Analyse du frontend
• Analyse du code d’automatisation
• Vérification de l’architecture, sécurité et structure
• Identification des bugs, failles et points d’amélioration
• Rapport final avec recommandations techniques

Objectif : avoir une vision claire et précise de l’état du code afin de préparer la stabilisation et la V1 propre.

Project Overview:

We have an existing AI-driven visual content generation POC that produces multi-layered illustrated scenes using:
• reference input images
• asset libraries
• reusable prompt structures
• scene templates
• AI vision models (OpenAI, Gemini, etc.)

The current POC was built by a professional agency and includes a working backend and generation pipeline.
Your role is to extend this POC into a more flexible, template-driven system with an Admin Panel and multi-scene rendering capabilities.

This is a technical role for a Senior Engineer with experience in AI vision pipelines, API orchestration, Node.js, and AWS.

What You Will Build:

1. Admin Panel & Template Builder
A browser-based tool where Admins can:
• upload/select visual assets (backgrounds, character references, props)
• create scene templates through drag-and-drop
• position elements using X/Y coordinates
• adjust scale and layer order (Z-index)
• add and edit text blocks
• define “primary character regions” and “secondary character regions” within the scene
• save templates for reuse in different story configurations
Scene templates must be stored in a clean JSON format.

2. Template-Driven Rendering Engine
The engine should:
• read the Admin’s JSON template
• generate visual elements with the correct style and coherence
• produce variations of character assets (e.g., different poses or actions)
• place all generated elements into the final scene according to template coordinates
• support multi-page story generation (e.g., 10 pages for POC)
• output final pages as images and compile them into a simple PDF
All generation steps must run automatically using generic prompts.

3. Visual Consistency System
The system should maintain:
• stylistic coherence of primary characters across multiple scenes
• consistent design attributes derived from reference inputs
• coherent character variations (e.g., multiple poses) across scenes
• automated quality checks (e.g., embeddings or structural comparison)
• auto-regeneration if outputs deviate from the intended style or visual attributes
This must work using API-based models only (OpenAI, Gemini, etc.).

4. Integration With the Existing POC
You will receive:
• existing backend (Node.js + AWS Lambda + S3)
• existing scene generation pipeline
• initial templates and asset examples
• documentation from the previous development team
Your job is to extend and modularize the system, not rebuild it from scratch.

Deliverables (First Milestone)
• Admin Panel with functional drag-and-drop template builder
• JSON template schema
• engine that processes templates and generates one multi-layered scene
• clear architecture plan for extending the POC into multi-scene generation
• clean documentation for internal developers

Ideal Candidate
You have strong experience with:
• AI vision APIs (OpenAI Vision, Gemini, etc.)
• multi-step prompt pipelines
• automated scene generation
• Node.js + TypeScript
• AWS (Lambda, S3, API Gateway)
• building internal tools (admin dashboards, editors)
• image processing / compositing (Canvas, Sharp, Pillow, etc.)
You can take a POC and turn it into a production-ready module.

What To Include in Your Application
• examples of AI-driven visual generation systems you built
• description of how you orchestrated multi-step generation pipelines
• experience with compositing or template-based rendering
• your availability
• your hourly rate
• a short explanation of how you would structure a template-driven rendering engine

• 1️⃣ How would you design a template-driven rendering pipeline that reads a JSON layout and generates a multi-layered scene using AI vision APIs?
• 2️⃣ How would you maintain visual consistency of a character across multiple scenes using only API-based models (no fine-tuning)?
• 3️⃣ Which tools or libraries would you use to build a drag-and-drop Template Builder that outputs a JSON scene layout?