Run on the 1st and 15th of Every Month | CronBase

const cron = require('node-cron');
const { exec } = require('child_process');

// Schedule task to run on the 1st and 15th of the month at midnight UTC
cron.schedule('0 0 1,15 * *', () => {
  console.log('Starting semi-monthly processing job...');
  exec('/usr/local/bin/process-payroll.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`Execution error: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`Warnings: ${stderr}`);
    }
    console.log(`Output: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: \"UTC\"
});

# Add this line to your crontab using the 'crontab -e' command\n0 0 1,15 * * /usr/local/bin/run-biweekly-billing.sh >> /var/log/billing.log 2>&1

from apscheduler.schedulers.blocking import BlockingScheduler
import logging
import subprocess

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def run_biweekly_task():
    logger.info(\"Executing scheduled bi-weekly task\")
    try:
        result = subprocess.run([\"/usr/local/bin/backup-db.sh\"], capture_output=True, text=True, check=True)
        logger.info(f\"Task completed: {result.stdout}\")
    except subprocess.CalledProcessError as e:
        logger.error(f\"Task failed with error: {e.stderr}\")

scheduler = BlockingScheduler(timezone=\"UTC\")
# Trigger on the 1st and 15th day of every month at midnight
scheduler.add_job(run_biweekly_task, 'cron', day='1,15', hour=0, minute=0)

try:
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    pass

package main

import (
	\"fmt\"
	\"log\"
	\"os/exec\"
	\"time\"

	\"github.com/robfig/cron/v3\"
)

func main() {
	// Use UTC to avoid DST complications
	nyc, err := time.LoadLocation(\"UTC\")
	if err != nil {
		log.Fatalf(\"Failed to load timezone: %v\", err)
	}

	c := cron.New(cron.WithLocation(nyc))
	
	_, err = c.AddFunc(\"0 0 1,15 * *\", func() {
		log.Println(\"Starting semi-monthly database cleanup...\")
		cmd := exec.Command(\"/usr/local/bin/cleanup.sh\")
		out, err := cmd.CombinedOutput()
		if err != nil {
			log.Printf(\"Execution failed: %v, Output: %s\", err, string(out))
			return
		}
		log.Printf(\"Execution succeeded: %s\", string(out))
	})
	if err != nil {
		log.Fatalf(\"Failed to schedule cron job: %v\", err)
	}

	c.Start()
	select {}
}

package com.example.cron;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class SemiMonthlyScheduler {
    private static final Logger logger = LoggerFactory.getLogger(SemiMonthlyScheduler.class);

    // Standard Spring cron: second, minute, hour, day-of-month, month, day-of-week
    @Scheduled(cron = \"0 0 0 1,15 *\", zone = \"UTC\")
    public void executeSemiMonthlyJob() {
        logger.info(\"Starting scheduled semi-monthly ledger reconciliation...\");
        try {
            // Business logic goes here
            logger.info(\"Ledger reconciliation completed successfully.\");
        } catch (Exception e) {
            logger.error(\"Error executing ledger reconciliation: \", e);
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: semi-monthly-billing-job
  namespace: default
spec:
  schedule: \"0 0 1,15 * *\"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: billing-executor
            image: billing-service:latest
            command: [\"/bin/sh\", \"-c\", \"/app/run-billing.sh\"]
          restartPolicy: OnFailure