Boost Grafana Projects with Vollna's Tools

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.

Job Overview
We are seeking an experienced Data Engineer with strong hands-on expertise in Apache Flink, Python, and Spark to help design and build real-time data streaming pipelines. This role involves working with modern data engineering tools, cloud services, and DevOps practices to deliver scalable, reliable, and high-performance streaming solutions.

Responsibilities
- Design, implement, and optimize real-time streaming pipelines using Apache Flink, Spark, Kafka, or similar technologies.
- Develop and maintain ETL/ELT workflows and data processing jobs in Python.
- Build and manage CI/CD pipelines to automate deployment and monitoring of streaming applications.
- Collaborate with data engineers, DevOps teams, and solution architects to ensure seamless data flow across systems.
- Use Infrastructure as Code (IaC) tools such as Terraform, Ansible, or CloudFormation for environment provisioning.
- Manage and monitor streaming workloads on cloud platforms (AWS, GCP, or Azure).
- Implement observability and monitoring solutions using Prometheus, Grafana, ELK/EFK, or similar stacks.
- Ensure high availability, fault tolerance, and low latency across production streaming systems.
- Troubleshoot and tune the performance of distributed data processing workloads.

Required Skills & Experience
- Strong, hands-on experience with Apache Flink (DataStream API, Table API, CEP).
- Solid experience with Python for data engineering and streaming workloads.
- Experience with Apache Spark (batch or streaming).
- Proficiency with streaming platforms such as Kafka, Pulsar, or Kinesis.
- Experience with DevOps tools: Docker, Kubernetes, Jenkins, GitLab CI/CD, etc.
- Working knowledge of cloud messaging/streaming services (AWS Kinesis, GCP Pub/Sub, Azure Event Hubs).
- Good understanding of serialization formats: Avro, Parquet, Protobuf, etc.
- Experience implementing monitoring/alerting for distributed systems.
- Familiarity with microservices and REST API integrations.

Job Title: Flink Engineer (Streaming Pipeline)

Job Summary:
We are looking for a highly skilled engineer with strong experience in Apache Flink, DevOps practices, and real-time streaming data pipelines. The ideal candidate will design, build, and maintain robust data streaming solutions, ensuring reliability, scalability, and performance in production environments.

Key Responsibilities:
Design, implement, and optimize real-time data streaming pipelines using Apache Flink, Kafka, or similar technologies.
Develop and maintain CI/CD pipelines for automated deployment and monitoring of streaming applications.
Collaborate with data engineers, DevOps teams, and architects to ensure smooth data flow across systems.
Implement infrastructure as code (IaC) using tools like Terraform, Ansible, or CloudFormation.
Manage and monitor streaming workloads on cloud platforms (AWS, GCP, or Azure).
Build observability solutions using Prometheus, Grafana, or ELK stack.
Ensure high availability, low latency, and fault tolerance in production-grade streaming pipelines.
Participate in performance tuning, debugging, and troubleshooting complex streaming systems.

Required Skills & Experience:
Strong hands-on experience with Apache Flink (DataStream API, Table API, CEP).
Proficiency with Kafka, Spark Streaming, or Pulsar is a plus.
Experience with DevOps tools: Docker, Kubernetes, Jenkins, GitLab CI/CD, etc.
Working knowledge of cloud services (AWS Kinesis, GCP Pub/Sub, or Azure Event Hubs).
Strong programming skills in Java, Scala, or Python.
Good understanding of data serialization formats like Avro, Parquet, or Protobuf.
Experience with monitoring, alerting, and logging tools in distributed systems.
Familiarity with microservices and RESTful API integration.

Nice-to-Have:
Experience with Flink SQL and stateful stream processing.
Exposure to machine learning pipelines or real-time analytics.
Certification in AWS DevOps, GCP Data Engineer, or similar cloud certifications.

Company: Young Startup
Location: Belgium (Remote-first)
Product: OrderLemon

We’re a young and energetic startup growing the OrderLemon platform across Europe. Businesses rely on us to stay online, stay fast, and stay secure — and that’s where you come in. We’re looking for a DevOps Engineer who knows their way around PHP environments, virtual Linux systems, and Hetzner infrastructure.

What You’ll Do

You’ll be the guardian of our infrastructure: building, maintaining, and optimizing the virtual environments where OrderLemon runs. You’ll make deployments smoother, uptime higher, and scaling easier. You’ll work closely with developers to ship features quickly and safely.

Your Skills
• Strong experience with Linux servers & virtualization
• Comfortable managing Hetzner Cloud instances
• Good knowledge of PHP runtime environments
• Familiar with CI/CD, GitHub workflows, and automation
• Solid understanding of networking, DNS, Domains, security basics, and monitoring
• Good English and the ability to collaborate in a remote team

What We Offer
• Fully remote job anywhere in Europe
• Flexible working schedule
• Modern, minimal bureaucracy startup environment
• Real ownership over our infrastructure
• Direct impact on a platform expanding across countries
• Supportive, collaborative team

How to Apply

Share your GitHub, past projects, or a short overview of your DevOps experience. Quick, simple process — we value skills over paperwork.

Join OrderLemon and help power the engine behind a global e-commerce platform.

Project Description:
Looking for a data engineer to build a real-time streaming pipeline that captures trading data from Hyperliquid's L4 feed — trades, order book changes, and liquidations. The system must handle high throughput (~100k events/min) without memory issues.
Technical Architecture
Data Pipeline



Real-time ingestion service with auto-reconnection logic
Redpanda message buffer for crash protection and data replay
ETL worker service with batch processing and retry mechanisms
Real-time OHLCV aggregation using ClickHouse materialized views
Data transformation and normalization for structured time-series storage



Storage & Performance



ClickHouse time-series database optimized for financial data
Handles millions of daily inserts with microsecond precision
Automated data partitioning and retention policies
Multi-timeframe candle aggregation (1m/5m/15m/1h/4h/1d)



Monitoring & Visualization



Grafana dashboard with real-time price charts and liquidation tracking
Health monitoring API with comprehensive system diagnostics
Production-ready error handling and observability
Containerized deployment with Docker Compose orchestration



Infrastructure



Single-command deployment on DigitalOcean
Multi-service architecture with proper isolation
Environment-based configuration management



Milestones



Core Pipeline — Ingestion, worker, Redpanda, ClickHouse working. Data flowing end-to-end. Health check API functional.
Dashboard — Grafana panels live with real-time data. All filters working.
Deployment + Handover — System running on DigitalOcean. Documentation and walkthrough provided.



Skills: Python (asyncio), Kafka/Redpanda, ClickHouse, Docker, Grafana, FastAPI

We are seeking an expert to build an AI-driven analytics layer and dashboard for our extensive log data stored on Loki. The ideal candidate will have experience in creating intelligent systems that can interpret plain English text, execute a series of steps to understand context, and derive actions, summaries, and reasons. Familiarity with tools like Warp.dev is a plus. Additionally, the candidate should be skilled in generating dashboards for unstructured log data.

We need someone to build a Cursor-like analytics layer for our logs stored in Loki.
We have terabytes of log data, and we want to build an AI-driven analytics and orchestration layer where the user can type plain English, and the AI will:

Understand the context

Execute a series of steps automatically

Run the necessary API calls or queries

Derive insights, actions, summaries, and reasoning

If you’ve worked with Warp.dev, you know how it automatically executes a sequence of commands to understand and analyze data — we want to build a similar smart analytics and action engine on top of our log data.

We also need automatic dashboard generation for unstructured log data.

So AI will recognize the patterns of log data and automatically derive the realtime pipeline to stream transformed data into dashboards

We have terabytes of logs
When user selects I want to generate dashboard for service ABC from kubernetes cluster
It will have lot of variety of logs
How will you generate the dashboard for the service or graphs


The user journey is

He selects the service and want to generate graphs
The AI to take sample of 100mb logs of its first time which will have all variety of logs
Then derive patterns
Then based on the patterns derive the graph or dashboard with real time streaming and transformation layers

If you are confident and have experience building such AI orchestration layers, please contact us.

Overview:
We are seeking an experienced AWS backend engineer to build, support, and audit a production IoT telemetry platform built on AWS. The system currently ingests continuous telemetry from deployed field devices and writes to PostgreSQL (RDS) via API Gateway and Lambda.
In addition to production ownership, this role may include:
Designing a formal partner-facing API (Phase 2)
Supporting secure dashboarding/visualization workflows for troubleshooting and operational visibility
This is a hands-on cloud systems role with direct responsibility for system reliability, scalability, and transferability.
Current Production Architecture (Must Be Fully Supported & Reproducible)
Ingestion Flow:
IoT device → HTTPS webhook → AWS API Gateway → AWS Lambda
Processing in Lambda:
JSON validation
Type coercion
Derived metric calculations (e.g., dew point)
Batch inserts into PostgreSQL
Database:
AWS RDS (PostgreSQL)
(Aurora Serverless recently deprecated for cost reasons)
Security:
VPC + Security Groups for Lambda ↔ RDS
IP allowlisting + DB credentials for external partners
Read-only roles for partners
You must be able to recreate this entire system in a clean AWS account from documentation alone.
Primary Responsibilities – Phase 1 (System Support & Duplication)
1. Production Support & Reliability
Own stability of:
API Gateway
Lambda
RDS/Postgres
CloudWatch logging
Diagnose:
Cold starts
Connection pooling timeouts
Failed inserts
Implement:
Structured logging
Metrics and alarms
Safe rollback via Lambda versions
2. Full AWS Stack Rebuild (From Scratch)
You will:
Stand up:
API Gateway
Lambda
VPC networking
PostgreSQL RDS
IAM roles & security policies
Implement:
Schema
Indexing
Secure networking
Deliver:
Clean IaC or setup documentation
Architecture diagrams
Disaster recovery & redeploy instructions
3. Data Integrity & Time Handling
Harden:
UTC rollover logic
Timestamp derivation rules
Guarantee:
Idempotent inserts
No duplicate telemetry rows
Deliver:
Validation SQL
Data consistency checks
4. PostgreSQL Optimization & Scaling
Index strategy for:
(device_id, timestamp)
Storage growth forecasting
Partitioning / retention strategy (if needed)
Scaling model:
100 → 1,000 → 10,000 devices
5. Dashboarding & Analytics Enablement (Support Scope)
You will not be asked to build a heavy UI, but must:
Design a safe analytics layer that:
Prevents dashboards from hitting production write tables
Support:
Aggregated tables or read replicas
Preferably support:
Grafana
Or equivalent observability/dashboard tools
Provide:
Example SQL views for trend analysis
Secure connector strategy
Phase 2 – Partner API Roadmap (Planned Follow-On Work)
Build a formal external API for:
Telemetry access
Aggregated performance metrics
Service diagnostics
Design:
Authentication & RBAC
Rate limiting
Partner scoping
Replace:
Direct SQL access for external partners
REST or GraphQL acceptable

Phase 2 will be separately scoped and separately funded.
Required Skillset (Strict)
7+ years AWS/cloud backend experience
Expert-level:
AWS Lambda
API Gateway
PostgreSQL (RDS)
VPC & Security Groups
IAM
Strong in:
High-write ingestion pipelines
Time-series data modeling
Production incident response
Cost-aware scaling design
Must be able to:
Rebuild production systems from documentation
Independently design scalable AWS architectures

Job Description:

We are looking for an experienced AWS Terraform DevOps Engineer to join our team for a long-term project.
Candidate must have a minimum of 3 years of commercial experience and strong expertise in the technologies listed below.

Requirements:

✔ Strong hands-on experience with AWS services:
• EC2, S3, RDS, ECS/EKS, Lambda, VPC

✔ Proficiency with Infrastructure-as-Code tools:
• Terraform (primary), CloudFormation

✔ Solid experience with containerization and orchestration:
• Docker, Kubernetes, Helm

✔ Practical knowledge of CI/CD tools:
• GitLab CI, Jenkins, AWS CodePipeline

✔ Strong understanding of networking fundamentals:
• TCP/IP, DNS, Firewalls, Load Balancing

✔ Experience with monitoring & logging tools:
• Prometheus, Grafana, CloudWatch, ELK Stack

✔ Knowledge of cloud security best practices and compliance standards

Additional Expectations:
• Ability to work independently and proactively
• Clear communication and reliability
• Willingness to commit long-term

If you meet the requirements and are ready to join a stable project, we’d be happy to hear from you.

Skills: System Admin, Linux, DNS, Amazon Web Services, Ubuntu, Docker, AWS Lambda, Jenkins, Kubernetes, Terraform

We are looking for an experienced DevOps Engineer to support, optimize, and expand our
server infrastructure hosted on Hetzner Cloud and Dedicated Servers.
This role requires deep expertise in Linux systems, automation, containerization, and secure,
scalable infrastructure design.
Responsibilities
 Configure, maintain, and optimize Hetzner Cloud and dedicated servers
(Ubuntu/Debian)
 Manage Docker environments and container orchestration practices
 Build or improve CI/CD pipelines (GitLab CI, GitHub Actions, or similar)
 Implement monitoring & alerting (Prometheus, Grafana, etc.)
 Perform performance tuning (network, compute, storage)
 Apply security hardening: firewall rules, SSH best practices, Fail2ban, etc.
 Automate recurring tasks (Ansible/Terraform preferred)
Requirements
 Proven experience working with the Hetzner hosting ecosystem
 Strong Linux administration skills (Debian/Ubuntu preferred)
 Solid experience with Docker-based workflows and deployments
 Practical experience with CI/CD tools
 Familiarity with Infrastructure-as-Code (Ansible, Terraform)
 Clean, structured, and well-documented working style
 Good communication skills (English)
Nice-to-Have
 Experience with Kubernetes (K3s, self-managed, or hybrid setups)
 Experience scaling high-traffic APIs or web applications
 Knowledge of load balancers and reverse proxy systems (HAProxy, Traefik, Nginx)
Project Details
 Start: Immediately
 Workload: 20-30 hours (depending on need)
 Long-term cooperation possible
How to Apply
Please include:
1. A short introduction and relevant experience
2. Examples of previous DevOps or Hetzner-related projects

3. Your hourly rate
4. Your upcoming availability

Charger logistics Inc. is a world- class asset-based carrier with locations across North America. With over 20 years of experience providing the best logistics solutions, Charger logistics has transformed into a world-class transport provider and continue to grow.
We are seeking a skilled and performance-minded .Net Core Developer to support and evolve our distributed system of over 100 microservices, built primarily with .NET Core and PostgreSQL. The ideal candidate has deep experience in backend development, service-to-service communication, and infrastructure-level tools like service mesh, and observability platforms. You will work closely with DevOps, QA, and frontend teams to ensure high availability, scalability, and maintainability of our services.

#Responsibilities:-
* Design, develop, and optimize high-performance backend microservices using .NET Core/C#.
* Implement distributed tracing, logging, and metrics for observability using tools like OpenTelemetry, Prometheus, and Grafana.
* Optimize service-to-service communication and database access to reduce latency and improve throughput.
* Write scalable SQL queries and optimize PostgreSQL usage, indexing, and connection handling.
* Contribute to service discovery, dynamic routing, and rollout strategies (e.g., blue/green, canary).
* Collaborate with QA to improve testability and traceability in a distributed system.
* Participate in architecture reviews and contribute to best practices for microservices at scale.
* Maintain CI/CD integration pipelines and ensure backend services deploy reliably.
* Troubleshoot and debug production issues using logs, traces, metrics, and profiling tools.


#Requirements:-
* 5+ years of backend development experience, including 2+ years in a microservices environment.
* Strong hands-on experience with .NET Core (C#) and PostgreSQL.
* Experience with distributed tracing, metrics, and log aggregation tools (e.g., Jaeger, Prometheus, Loki, Grafana).
* Deep understanding of REST, gRPC, and asynchronous messaging patterns (e.g., Kafka, RabbitMQ).
* Familiarity with Kubernetes, Docker, and container-based deployments.
* Understanding of software performance profiling, benchmarking, and optimization.
* Strong grasp of service resilience patterns: timeouts, retries, bulkheads, circuit breakers.
* Excellent problem-solving and debugging skills in large-scale systems.

#Preferred Qualifications:-
* Experience working with Istio, Consul, or another service mesh.
* Familiarity with Event Sourcing, CQRS, and DDD patterns.
* Exposure to Infrastructure as Code tools (Terraform, Helm).
* Experience with other databases like Redis, MongoDB, or TimescaleDB.
* Knowledge of cloud platforms like AWS, Azure, or GCP.

Type: Remote
Goal: Build, connect, maintain and continuously optimize a two-strategy algorithmic trading system for MT4 (Intraday + Swing) with an advanced risk engine, performance monitoring, and automation layer. This person must be able to code EAs, integrate tools, connect servers/brokers/APIs, and help architect the full trading environment — not just write scripts.

Core Responsibilities
• Develop algorithmic trading systems in MQL4/MQL5 (clean, modular, scalable code).
• Build and integrate the entire stack:
• MT4/MT5 deployment
• VPS setup and multi-instance architecture
• Broker/API/webhook connectivity
• Automation scripts and monitoring
• Architect a Risk Management Engine including:
• Volatility-based position sizing (ATR)
• Daily loss limits + account drawdown protection
• Exposure and correlation control across symbols
• Adaptive trailing stops + partial take profits
• Implement trading logic for two bots:
1) Intraday EA: VWAP, ATR bands, breakout/mean-reversion signals
2) Swing EA: EMA + ADX trend filtering, pyramiding, ATR trailing
• Build internal tools for backtesting & optimization:
• Tick-data backtests
• Walk-forward analysis
• Monte Carlo stress simulations
• Connect the EA system with external tools:
• Logging to CSV/API
• Alerts & dashboards (optional Python/Grafana)
• Optional integration with copy-trading/investor infrastructure
• Maintain code quality, documentation and experiment reports.

Minimum Qualifications
• 3+ years experience building EAs for MT4/MT5.
• Direct experience running bots in live accounts, not only backtests.
• Strong understanding of risk management & market microstructure.
• Experience with VPS deployments + MT4 multi-terminal setups.
• Ability to identify over-optimization vs robust performance.
• Comfortable designing architecture, not just coding tasks.

Nice to Have
• Experience connecting MT4/MT5 to external systems via Python/API.
• Machine Learning exposure for strategy enhancement.
• Experience with copy-trading platforms or PAMM/MAM.
• Familiarity with dashboard building (Grafana/Streamlit/Node).

What Success Looks Like (First 90 Days)
• Both EAs running in Demo with real tick-data backtests.
• Weekly optimization reports + drawdown reduction strategies.
• Production-ready version with monitoring & risk controls.
• System prepared for scaling to live trading/copy-trading.

Non-Negotiable
• You must think like an engineer and a strategist — not a code executor.
• You must be comfortable taking decisions, suggesting improvements, and defending your approach with data.

Type: Remote
Goal: Build, connect, maintain and continuously optimize a two-strategy algorithmic trading system for MT4 (Intraday + Swing) with an advanced risk engine, performance monitoring, and automation layer. This person must be able to code EAs, integrate tools, connect servers/brokers/APIs, and help architect the full trading environment — not just write scripts.

Core Responsibilities
• Develop algorithmic trading systems in MQL4/MQL5 (clean, modular, scalable code).
• Build and integrate the entire stack:
• MT4/MT5 deployment
• VPS setup and multi-instance architecture
• Broker/API/webhook connectivity
• Automation scripts and monitoring
• Architect a Risk Management Engine including:
• Volatility-based position sizing (ATR)
• Daily loss limits + account drawdown protection
• Exposure and correlation control across symbols
• Adaptive trailing stops + partial take profits
• Implement trading logic for two bots:
1) Intraday EA: VWAP, ATR bands, breakout/mean-reversion signals
2) Swing EA: EMA + ADX trend filtering, pyramiding, ATR trailing
• Build internal tools for backtesting & optimization:
• Tick-data backtests
• Walk-forward analysis
• Monte Carlo stress simulations
• Connect the EA system with external tools:
• Logging to CSV/API
• Alerts & dashboards (optional Python/Grafana)
• Optional integration with copy-trading/investor infrastructure
• Maintain code quality, documentation and experiment reports.

Minimum Qualifications
• 3+ years experience building EAs for MT4/MT5.
• Direct experience running bots in live accounts, not only backtests.
• Strong understanding of risk management & market microstructure.
• Experience with VPS deployments + MT4 multi-terminal setups.
• Ability to identify over-optimization vs robust performance.
• Comfortable designing architecture, not just coding tasks.

Nice to Have
• Experience connecting MT4/MT5 to external systems via Python/API.
• Machine Learning exposure for strategy enhancement.
• Experience with copy-trading platforms or PAMM/MAM.
• Familiarity with dashboard building (Grafana/Streamlit/Node).

What Success Looks Like (First 90 Days)
• Both EAs running in Demo with real tick-data backtests.
• Weekly optimization reports + drawdown reduction strategies.
• Production-ready version with monitoring & risk controls.
• System prepared for scaling to live trading/copy-trading.

Non-Negotiable
• You must think like an engineer and a strategist — not a code executor.
• You must be comfortable taking decisions, suggesting improvements, and defending your approach with data.

Position: DevOps Engineer (Full-time, On-Site)
Additional Role: Scrum Project Manager
Budget: 75 USD for 1 month (trial or contract-based)
Availability: Scrum Ceremonies, Ad-hoc urgency support and emergency breakouts
Location: (Isb, Pakistan or even world wide for a talented individual )



Role Summary

We are hiring a DevOps Engineer who will stay on-site and manage our main server, deployments, security, performance, and daily technical operations.
In addition, the candidate will act as a Scrum Project Manager ensuring proper planning, execution, and reporting of all development activities through complete Scrum ceremonies.

This role requires someone who is reliable, fast, disciplined, and available immediately when technical emergencies arise.


Key Responsibilities

1. DevOps & Server Management

● Full management of Linux server (setup, updates, monitoring, maintenance).
● CI/CD pipelines using GitHub, GitLab CI, or Jenkins.
● Manage Docker containers and deployments.
● Server security, firewall, SSL, access control, and hardening.
● Daily backups and recovery testing.
● Monitoring systems (Grafana, Prometheus).
● Troubleshooting performance issues and ensuring 24/7 uptime.
● Database management: MySQL, PostgreSQL, MongoDB.
● Deployment of applications and API services.
● DNS, reverse proxies, load balancing.

2. Scrum Project Management (Daily)

The engineer must run and maintain ALL Scrum ceremonies:

● Daily Stand-Ups
Short daily team sync, reviewing progress and blockers.

● Sprint Planning
Define sprint goals, timelines, backlog prioritization.

● Sprint Backlog Management
Maintain updated tasks on ClickUp, Jira, or similar tools.

● Sprint Review
Present outcomes, completed tasks, demos when needed.

● Sprint Retrospective
Identify what went well, what needs improvement, and action steps.

● Burndown Charts & Reporting
Daily progress tracking and clear communication to management.

3. Emergency & Ad-Hoc Support

● Immediate availability in case of critical server incidents.
● Quick troubleshooting during unexpected outages.
● Ability to support high-pressure situations with rapid response.



Requirements

● 3+ years DevOps experience.
● Strong Linux server administration.
● CI/CD setup experience.
● Docker and containers expertise.
● Strong troubleshooting and incident response.
● Ability to run Agile and Scrum ceremonies effectively.
● Excellent communication and discipline.
● Must be available ad-hoc for emergencies.



Preferred Qualifications

● Experience with ERPNext or similar ERP systems.
● AWS, DigitalOcean, or cloud platforms.
● Security certifications or DevOps certifications.
● Kubernetes experience is a plus.


Compensation

● 75 USD total for one-month contract (trial month or project engagement).

Recruiting Intermediate Operations Engineer (Game/ AWS)

We are a cutting-edge game development company dedicated to crafting high-quality, immersive, and deeply engaging interactive entertainment. Guided by the philosophy that creativity makes the world vibrant, we harness technology to fuel innovation and artistry to shape experiences, committed to excellence in our R&D. We look forward to collaborating with passionate gamers and creators to embark on a new era of gaming adventures.

Conditions of Remuneration
1. Base salary plus performance bonus: USD 2,750 to USD 11,000.
2. Workplace: Dubai, UAE
3. Working hours: 12-hour shift, two shifts per day, with one day off per week.
4. Additional benefits: Complimentary meals, accommodation, and visa processing; monthly team-building activities; birthday cash gifts; annual bonus; 10 days of paid family leave after one year of service, and 15 days after two years; round-trip airfare reimbursement.
5. Be able to communicate in fluent Chinese.

position statement
1.AWS Infrastructure Deployment and Management
Design and deploy game server architecture based on the AWS ecosystem (EC2, RDS, S3, VPC, CloudWatch, GameLift, etc.), handling all server operations including new server launches, version updates, hot fixes, and server consolidation.
Ensure high availability and scalability of game servers by optimizing server configurations for high-concurrency, low-latency gaming scenarios, with service SLA guaranteed at 99.99% or higher.
2. Daily Operations and Troubleshooting
Set up a CloudWatch/Prometheus+Grafana monitoring system to track real-time core metrics like CPU, memory, disk, and network usage for resources such as EC2 and RDS. Configure tiered alert policies and optimize alert logic to prevent alert fatigue.
Quickly respond to and troubleshoot game server issues (including lag, downtime, or data anomalies), develop contingency plans, lead post-incident reviews for major failures, and deliver optimization solutions.
Responsible for game data backup, recovery, and disaster recovery plan implementation to ensure player data security.
3. Automation and Cost Optimization
Develop Shell/Python scripts to automate routine operations including batch deployment, resource monitoring, and self-healing for system failures.
Monitor AWS resource usage, analyze cost breakdowns, and develop optimization strategies to reduce cloud resource costs.
Drive the implementation of DevOps processes, collaborate with development teams to optimize CI/CD workflows, and enhance release efficiency.
4. Security and Collaboration
Oversees security compliance management in AWS environments, including IAM permission configuration, vulnerability scanning and remediation, and network security protection.
Collaborate closely with game development and operations teams to understand business requirements, provide operational solutions, and deliver standardized operation and maintenance documentation.

job requirements
1. Experience Requirements
3-5 years of IT operations experience, with at least 1 year of experience in game industry or AWS cloud platform operations. Overseas AWS multi-region deployment experience is preferred.
We seek candidates with hands-on experience in managing high-concurrency and high-traffic game servers, particularly those with expertise in version updates, cross-server coordination, and holiday maintenance support.
2. Technical capabilities
Proficient in Linux operating systems (CentOS/Ubuntu), with expertise in system performance optimization and network troubleshooting.
Proficient in AWS core services (EC2, VPC, RDS, S3, CloudWatch, ELB, GameLift, etc.), capable of independently designing cloud-based game server architectures.
Proficiency in at least one scripting language (Shell/Python) and foundational containerization skills (Docker/Kubernetes) for operations and maintenance.
Proficient in configuring and operating monitoring and log analysis tools such as CloudWatch, Prometheus, Grafana, and ELK.
3. Bonus Points
AWS certifications (SysOps Administrator, DevOps Engineer, or Solutions Architect) are preferred.
Demonstrates strong problem-solving skills and can handle high-pressure emergency troubleshooting in the gaming industry.
Strong cross-team communication skills, able to clearly align with and drive the implementation of requirements from development and operations teams.
Has experience in writing operation and maintenance documentation and establishing standardized processes.

• Ready to work on site
• Can speak fluent chinese
• Have an experience more than a year

We are seeking an expert to build an AI-driven analytics layer and dashboard for our extensive log data stored on Loki. The ideal candidate will have experience in creating intelligent systems that can interpret plain English text, execute a series of steps to understand context, and derive actions, summaries, and reasons. Familiarity with tools like Warp.dev is a plus. Additionally, the candidate should be skilled in generating dashboards for unstructured log data.

We need someone to build a Cursor-like analytics layer for our logs stored in Loki.
We have terabytes of log data, and we want to build an AI-driven analytics and orchestration layer where the user can type plain English, and the AI will:

Understand the context

Execute a series of steps automatically

Run the necessary API calls or queries

Derive insights, actions, summaries, and reasoning

If you’ve worked with Warp.dev, you know how it automatically executes a sequence of commands to understand and analyze data — we want to build a similar smart analytics and action engine on top of our log data.

We also need automatic dashboard generation for unstructured log data.

So AI will recognize the patterns of log data and automatically derive the realtime pipeline to stream transformed data into dashboards

We have terabytes of logs
When user selects I want to generate dashboard for service ABC from kubernetes cluster
It will have lot of variety of logs
How will you generate the dashboard for the service or graphs


The user journey is

He selects the service and want to generate graphs
The AI to take sample of 100mb logs of its first time which will have all variety of logs
Then derive patterns
Then based on the patterns derive the graph or dashboard with real time streaming and transformation layers

If you are confident and have experience building such AI orchestration layers, please contact us.

We are seeking an experienced cloud infrastructure engineer to design, build, and deploy an IaaS setup using Apache CloudStack, CEPH, and Zabbix/Grafana. The ideal candidate will have a strong understanding of cloud architecture and be able to integrate monitoring and management tools effectively. Responsibilities include configuring the infrastructure, ensuring scalability, and implementing best practices for performance and security. A solid background in cloud solutions and experience with open-source technologies is essential.

Project: Build a scalable multi-tenant SaaS architecture on AWS for JobTalk.ai
Skills Needed: AWS EKS, Kubernetes, Helm, Terraform, RDS, VPC, SaaS multitenancy, CI/CD, microservices, security, enterprise provisioning
About the Project
JobTalk.ai is an AI Voice Agent SaaS platform for enterprise recruiting teams. We need a senior AWS Managed Kubernetes (EKS) expert to design and implement a clean, secure, scalable multi-tenant SaaS architecture.
Our goals:
One codebase shared across all customers
Isolated databases per tenant (critical)
Zero-friction onboarding: adding a new enterprise client should be fast and automated
Ability to support tenant-specific config and occasional custom features
High availability, strong security, and easy scaling
What You Will Build
1. Multi-Tenant Architecture on AWS
Core platform deployed on EKS (Managed Kubernetes)
Each tenant gets:
Dedicated DB instance (Postgres/MySQL preferred)
Isolated namespace or dedicated deployment strategy
Config based on tenant metadata
Shared services remain global (auth, billing, event bus, logs, monitoring)

2. Automated Tenant Provisioning
You will create automated workflows to provision a new client in minutes:
Auto-provision DB
Run migrations
Generate secrets
Create Kubernetes resources
Set up tenant config + routing
Register tenant in central control plane
Tools expected: Terraform, Helm, AWS CDK, or equivalent.

3. CI/CD & Deployment
Set up GitHub/GitLab pipelines for:
Continuous deployment
Rolling updates to all tenants
Safe tenant-specific overrides
Canary deployments to reduce downtime

4. Security & Compliance
VPC + subnet strategy
IAM roles & policies
Secret management
Network isolation
Secure multi-tenant RBAC
Logging + audit trails

5. Optional Tasks
API Gateway + custom domain setup per tenant
Feature flags
Monitoring dashboards (Grafana, Prometheus, CloudWatch)
Cost optimization recommendations
Tech Stack (Target)

AWS EKS
AWS RDS
Terraform or AWS CDK
Helm
Docker
GitHub Actions
Redis/ElastiCache (optional)

Who We’re Looking For
5+ years with AWS + Kubernetes
Experience building multi-tenant SaaS (must-have)
Strong with Terraform/Helm automation
Solid understanding of security, scaling, and production workloads
Ability to architect and implement end-to-end
Strong communication and documentation skills
Deliverables
Full multi-tenant SaaS architecture design
EKS cluster setup (production-ready)
Automated tenant onboarding system
Database per-tenant provisioning
CI/CD pipeline implementation
Documentation for our team
Optional: handover training session

Role Overview
SwyftBooking is seeking an experienced DevOps Engineer to design, build, and manage our production infrastructure across all modules including flights, vacation rentals, car rentals, trucking, event ticketing, and more. This role requires deep expertise in cloud architecture, CICD, automation, security hardening, and maintaining highly available systems that support a fast-growing platform.

You will work closely with backend, frontend, mobile, and microservices teams to ensure seamless deployment, strong system reliability, and enterprise-grade security.

Key Responsibilities
Production Infrastructure
Build and maintain cloud-based production environments (AWS, GCP, or Azure).

Configure VPCs, load balancers, auto-scaling groups, NAT gateways, and DNS.

Implement infrastructure as code using tools such as Terraform or CloudFormation.

Ensure high availability, fault tolerance, and disaster recovery readiness for all services.

CI/CD Pipeline
Set up and manage CI/CD pipelines for MERN/MEAN, Flutter, and microservices using GitHub Actions, GitLab CI, or Jenkins.

Automate build, test, and deployment workflows across development, staging, and production.

Support containerization and orchestration with Docker and Kubernetes.

Microservices & Kafka
Deploy and monitor Kafka-based microservices used across SwyftBooking modules.

Implement event streaming, error monitoring, logging, and retry policies.

Optimize API gateway and inter-service communication for low latency and reliability.

Monitoring & Observability
Implement system monitoring using Prometheus, Grafana, Datadog, or CloudWatch.

Configure alerts for uptime, latency, CPU, memory, and service health.

Maintain centralized logging using ELK/EFK stacks.

Security & Compliance
Harden production environments following industry best practices.

Implement network-level and application-level firewalls.

Set up Identity and Access Management (IAM) with least-privilege policies.

Configure SSL/TLS certificates, HSTS, encryption at rest and in transit.

Monitor for vulnerabilities, perform patching, and ensure compliance with platform-wide security standards.

Support secure API integration with external vendors (Checkr, Stripe, Amadeus, Hotelbeds, etc.).

Automation & Optimization
Develop automation scripts using Bash, Python, or Node.js.

Optimize system performance, cost, and deployment speed.

Reduce manual operations by creating reliable workflows and automated processes.

Backup & Recovery
Configure automated backups, storage solutions, and snapshot strategies.

Conduct periodic disaster recovery testing.

Maintain business continuity plans for all SwyftBooking modules.

Collaboration
Work closely with backend developers, frontend developers, QA, and product teams.

Support development teams with testing environments, sandbox deployments, and rollout strategies.

Participate in architecture design and contribute to platform-wide scalability improvements.

Required Skills & Experience
3+ years of experience in DevOps, Site Reliability Engineering (SRE), or Cloud Engineering.

Hands-on experience with AWS, GCP, or Azure.

Strong knowledge of Docker, Kubernetes, and container orchestration.

Experience implementing complete CI/CD pipelines.

Good understanding of networking, load balancing, DNS, and cloud security.

Experience with Terraform, CloudFormation, or Ansible.

Familiarity with MongoDB, Node.js, React, Angular, and Flutter deployments.

Experience with Kafka or other event-streaming platforms.

Strong understanding of security protocols, IAM, encryption practices, and compliance.

Knowledge of monitoring tools such as Grafana, Prometheus, Datadog, ELK, or CloudWatch.

Preferred Qualifications
Experience with large-scale, multi-module systems or marketplace platforms.

Background supporting microservices architecture.

Prior experience in travel-tech or high-volume transactional systems.

Familiarity with payment gateways and secure payment flows.

Experience implementing zero-downtime deployments and blue-green/rolling updates.

What This Role Means for SwyftBooking
This DevOps Engineer will play a central role in preparing SwyftBooking for full production launch. You will ensure our infrastructure is stable, secure, scalable, monitored, and ready for millions of users across all service categories.

If you want, I can also:

Create a shorter job posting version,

Write an interview questionnaire,

Draft a DevOps onboarding checklist,

Or help define your production architecture diagram for the team.

Project Overview:
We are Upskill.Pro, a fast-growing AI Agent platform democratizing top-tier strategy consulting for managers and leaders. We function as a "Outcome-as-a-Service" partner, integrating diverse AI agents to solve complex business problems.

We are looking for a Part-Time Senior DevOps Engineer who specializes in AI/LLM Infrastructure. You will not just manage servers; you will orchestrate the lifecycle of AI agents, ensuring our global product interacts seamlessly with Cloud LLMs, Open WebUI, and n8n workflows.

Role Type: Part-time (Long-term potential)
Location: Remote (Global)
Language: Native/Fluent in Chinese (Mandarin) and English is a MUST.

🚀 The Mission (What you will do)
You will own the reliability, security, and performance of our AI infrastructure. This includes:
1. CI/CD & Automation (The Foundation)
Design and maintain robust CI/CD pipelines for our AI applications.
Automate deployment processes to ensure rapid and safe code releases.
Requirement: Move us from manual deployments to a fully automated "Click-to-Ship" environment.

2. AI Stack Optimization (Open WebUI + n8n + RAG)
Performance Tuning: Optimize the latency and throughput of Open WebUI and n8n self-hosted instances. Troubleshoot websocket connections and workflow execution bottlenecks.
RAG Ops: Maintain the vector database infrastructure and RAG pipelines, ensuring high availability for document retrieval (JSON/PDF parsing) .
Security: Harden the environment to protect sensitive user interaction data and PII . Manage API keys and secrets securely (Vault/AWS Secrets Manager).

3. Cloud & LLM Infrastructure (AWS + GCP)
Manage a hybrid cloud environment (AWS & GCP).
LLMOps: Monitor Cloud LLM (OpenAI, Anthropic, Gemini via Vertex AI) API usage, latency, and error rates. Implement alerts for quota limits and cost anomalies.
Observability: Set up comprehensive logging and monitoring dashboards (e.g., Grafana, Prometheus, or native cloud tools) to track system health and "Model Drift" .

🎯 Who We Are Looking For
1. Bilingual Communication: You can discuss complex technical architecture in Chinese with the core team and document/communicate in professional English for global operations.
2. DevOps Architect: 5+ years of experience with Linux, Docker, Kubernetes (optional but preferred), and Nginx.
3. AI/Low-Code Enthusiast: Proven experience self-hosting and scaling Open WebUI and workflow automation tools like n8n. You understand the specific resource needs of GenAI apps.
4. Cloud Native: Deep expertise in AWS (EC2, S3, RDS, VPC) and GCP.
5. Scripting: Proficient in Python and Bash.
6. Availability: Flexible to support a product running 24/7 globally; available for occasional emergency response.

🔧 Tech Stack
Core AI: Open WebUI, n8n, RAG (Vector DBs like Chroma/Qdrant/Pinecone).
Cloud: AWS, GCP.
Ops: Docker, GitHub Actions, Terraform (IaC).
LLM Integration: API Gateway management for OpenAI/Anthropic.

💙 Why Join Upskill.Pro?
1. Cutting-Edge Tech: Work with the latest Agentic workflows and LLM orchestration tools.
2. High Impact: Your work directly empowers managers and consultants globally.
3. Flexible & Remote: Work from anywhere, with a team that values output over hours.

• Please describe your experience deploying and scaling Open WebUI or n8n in a production environment. What were the main challenges?
• How do you handle API Key security and rate limiting when managing connections to multiple LLM providers (OpenAI, Claude, etc.)?
• Are you comfortable communicating via voice/video in both Mandarin Chinese and English?
• What is your approach to monitoring costs for Cloud LLM services?

We’re looking for a **DevOps / SecOps Engineer** to own our environments end-to-end and help us meet a clearly defined scope of infrastructure and security operations work already in place between CAIS and our infrastructure partner.

---
### The Role

You’ll be responsible for the **secure, reliable, and cost-effective operation of our cloud environments** (dev/stage/prod), as well as the **security posture** around them. This is a hands-on role combining classic DevOps with Security Operations: you’ll design and maintain infrastructure, automate delivery, harden systems, and build the tooling and processes that keep our environments resilient and compliant.

You’ll work closely with founders, engineers, and external partners, mostly async via Slack and ClickUp, with clear ownership over our DevOps/SecOps roadmap and KPIs.

---

### What You’ll Do

#### Infrastructure Operations (DevOps)

* Own and operate **production, staging, and development** environments (primarily cloud).
* Design and maintain **Infrastructure as Code** (e.g., Terraform) and reusable environment patterns.
* Manage **CI/CD pipelines**: build/release automation, artifact management, rollback workflows.
* Build and maintain **monitoring & observability**: metrics, logs, traces, alerting (e.g., CloudWatch, Grafana, Prometheus, OpenSearch/ELK, Datadog).
* Implement **backup & disaster recovery** strategies, including RPO/RTO definitions, restore tests, and runbooks.
* Optimize **capacity & performance**: autoscaling, right-sizing, load/perf testing support, and cloud cost optimization.
* Handle **network & platform operations**: VPC/VNet design, routing, firewalls/security groups, ingress/egress, DNS, TLS certs and renewals.
* Manage **container & runtime platforms** such as Kubernetes/EKS, ECS, or Nomad (cluster upgrades, node pools, registries, image lifecycle).
* Set up and manage **secrets and configuration**: secret stores (1Password, Vault, AWS Secrets Manager, SSM), rotation, and least-privilege access.

#### Security Operations (SecOps)

* Define and enforce **security baselines and hardening** (CIS/NIST-aligned) across OS, cloud, Kubernetes, and CI/CD.
* Implement and maintain **Identity & Access Management**: RBAC, SSO, least-privilege patterns, privileged access reviews, and joiner/mover/leaver processes.
* Run **patch & vulnerability management**: OS and container patching cadence, image rebuilds, SCA/SAST/DAST scanning, remediation tracking and reporting.
* Build and operate **threat detection & incident response** workflows: centralized logging/SIEM, alert triage, incident playbooks, coordination with forensics, post-incident reviews.
* Support **compliance** efforts (e.g., SOC 2, ISO 27001) with evidence gathering, policy upkeep, control mapping, and change records.
* Implement **data protection** measures: encryption at rest and in transit, KMS/key management, data classification, and retention enforcement.

#### Developer Experience & Collaboration

* Triage and respond to **requests via ClickUp and Slack**; communicate clearly and see issues through to completion.
* Build **self-service capabilities** for developers: golden templates, starter repos, internal tooling/CLIs, and clear internal docs.
* Support **release management**: change windows, approvals, canary/blue-green deployments, feature flags.
* Maintain high-quality **documentation**: runbooks, architecture diagrams, environment inventories, service catalog entries, and “how-to” guides.

#### Deliverables & Outcomes

Over time, you’ll be responsible for delivering and maintaining:

* IaC **blueprints/repositories** for our standard environments.
* **Monitoring dashboards & alert policies** for key services and SLOs.
* **Runbooks & incident playbooks** for common and high-risk scenarios.
* **Security baseline checklists** and recurring hardening reports.
* A **monthly ops report** summarizing uptime/SLOs, incidents & RCAs, cloud costs and savings, and security risk/vulnerability posture.

• Describe your recent experience with similar projects
• Please list any certifications related to this project
• Describe common challenges of maintaining SLAs
• How do you create a dependency map for systems operating in multi-tier architecture?
• How do you operationalize your projects?