DEV Community: Jayant

you can prove you know a secret without ever revealing it. no, seriously. the math actually works. wrote a breakdown of how ZK proofs work

Jayant — Fri, 10 Apr 2026 17:00:48 +0000

Jayant

Apr 10

ZK from Scratch #1: What is a Zero-Knowledge Proof?

#zeroknowledge #web3 #solana #web

Comments

5 min read

ZK from Scratch #1: What is a Zero-Knowledge Proof?

Jayant — Fri, 10 Apr 2026 17:00:25 +0000

TL;DR

A ZK proof lets you prove you know something without revealing what you know
Every ZK system must satisfy three properties: completeness, soundness, and zero-knowledge
The Alibaba's Cave protocol is the simplest way to understand how this actually works
One random check can replace a million checks — and that's why ZK proofs are tiny

What is a Zero-Knowledge Proof?

Imagine you're at airport security. A gate scans your passport behind a screen and shows the officer a single green light: "This person is over 18."

The officer learns nothing else. Not your name, not your birthday, not your nationality. Just: over 18 — yes or no.

That's a zero-knowledge proof. You proved a fact without revealing the underlying data.

More precisely: a ZK proof is a cryptographic method where a prover convinces a verifier that a statement is true, without revealing anything beyond the truth of that statement.

The verifier learns exactly one bit of information: true or false. Nothing else leaks.

Why does this matter?

Because right now, proving things on the internet requires showing your work.

Want to prove you have enough money for a loan? Show your entire bank statement.
Want to prove you're a citizen? Hand over your passport with every detail visible.
Want to prove a computation was done correctly on-chain? Re-execute the entire thing.

Every one of these leaks more information than necessary. ZK fixes this. You prove the result without exposing the inputs.

This is not a theoretical concept — ZK proofs are already running in production. Rollups use them to compress thousands of transactions into a single proof. Private payment protocols use them to hide sender, receiver, and amount. Identity systems use them so you can prove you're human without revealing who you are.

How does it work? The Three Properties

Every ZK proof system — whether it's a cave protocol on a napkin or a billion-dollar rollup — must satisfy exactly three properties:

Property	What it protects	Plain English
Completeness	The honest prover	If you're telling the truth, the system will always accept your proof
Soundness	The verifier	If you're lying, the system will almost always catch you
Zero-knowledge	The prover's privacy	The verifier learns nothing beyond "true or false"

Think of it like a metal detector at a courthouse:

Completeness = it lets innocent people through (no false rejections)
Soundness = it catches people carrying weapons (no false passes)
Zero-knowledge = it doesn't X-ray your entire body (no unnecessary exposure)

Notice that soundness says "almost always," not "always." There's a tiny probability a cheater gets lucky on any single round. This is why ZK protocols run multiple rounds — each round shrinks the cheating probability exponentially.

The Alibaba's Cave Protocol

This is the most famous ZK example in cryptography, and it's been the go-to teaching tool for over 35 years. Here's how it works:

Setup: A circular tunnel splits into Path A and Path B. At the back, the two paths meet at a locked door. Peggy (the prover) claims she knows the magic word that opens the door.

The protocol (each round):

Peggy walks into the cave alone and randomly picks Path A or Path B. Victor (the verifier) cannot see which path she chose.
Victor stands at the entrance and shouts a random challenge: "Come out from Path A!" or "Come out from Path B!"
Peggy responds. If she's already on the correct path, she just walks out. If she's on the wrong path, she uses the magic word to unlock the door and cross over.
Repeat for many rounds.

Why this works — checking all three properties:

Completeness: If Peggy actually knows the magic word, she can always come out from whichever path Victor asks. She passes every round, every time.

Soundness: If Peggy is faking it (doesn't know the magic word), she's stuck. When she's on the wrong path, she can't cross over. She has a 50% chance of getting lucky on any single round.

But here's the math: each round is independent. The probabilities multiply.

Round 1:  1/2 chance of cheating successfully
Round 2:  1/2 x 1/2 = 1/4
Round 10: (1/2)^10 = 1/1,024
Round 20: (1/2)^20 = 1/1,048,576
Round 30: (1/2)^30 = 1/1,073,741,824

After 20 rounds, there's less than a one-in-a-million chance a cheater gets through. After 30 rounds, one in a billion.

Zero-knowledge: Victor never hears the magic word. He only sees Peggy walking out of the path he asked for. He learns "Peggy knows the word" but nothing about what the word is.

The Non-Transferability Property

Here's something subtle that most explanations skip: Victor cannot convince anyone else that Peggy knows the secret.

Why? Because a video of a real proof looks identical to a staged one. Victor could have told Peggy in advance which path to take, and the recording would look the same.

This is a feature, not a bug. It means proofs are non-transferable — they convince the verifier and nobody else. This prevents the verifier from using the proof to impersonate the prover.

Quick Test: ZK or Not ZK?

Try to identify which of these are zero-knowledge:

Scenario	ZK?	Why?
Sending your password to a server to log in	No	Server sees your password — full information leak
Proving your age >= 21 with only a true/false response	Yes	Verifier learns one bit: old enough or not
Showing your bank statement to a landlord	No	Landlord sees your full financial history
Proving you have enough crypto without revealing your balance	Yes	Verifier learns "enough" — nothing about the actual amount
Bitcoin's Proof of Work (publishing the nonce)	No	The nonce is published publicly — everyone can see it

The pattern: if the system only outputs true or false and nothing else leaks, it's ZK.

Why One Random Check Is Enough

Here's the part that makes ZK proofs practical instead of just theoretical.

In real ZK systems (not cave analogies), computations are converted into polynomials — mathematical equations. The Schwartz-Zippel Lemma tells us something powerful:

Two different polynomials of degree d can agree on at most d points.

If the prover claims to have the correct polynomial (representing the correct computation), the verifier picks one random point from an astronomically large field (like 2^256 possible points) and asks the prover to evaluate there.

If the answer matches: the prover almost certainly has the correct polynomial. The probability of a false match is d/2^256, which is essentially zero.
If the answer doesn't match: the prover is definitely lying.

One random check replaces millions of checks. This is why ZK proofs can be just a few hundred bytes, no matter how complex the original computation was.

What's Next

This is Blog 1 of the "ZK from Scratch" series. I'm learning this stuff in real-time and documenting what clicks.

Coming up next: Interactive vs Non-Interactive Proofs — why the cave protocol doesn't work on a blockchain, and how the Fiat-Shamir heuristic fixes everything.

CAP Theorm

Jayant — Mon, 07 Jul 2025 14:31:19 +0000

C - Consistency, Every Read receive most recent write or an error.
Consistency defined in CAP Theorm is quite different from Consistency in ACID DB Transaction

A - Availability, Every request received must give some response, the response returned will be the most recent data, but it can't gaurentee that data is upto to Date.

P - Partition Tolerance, The system continues to work, even if some nodes goes down.

It states that On Partition (network split, some nodes can't communicate others) you can either provide consistency or availability.

If we Choose Consistency - the system will return error or timeout if certain data can't be returned with a guarentee that it is upto date.
- In a Banking system we prefer consistency over availability.
If we Choose Availability - the system will process the query and try to return the most recent data, however it is not guarenteed it is uptoDate.
- In a Social Media Platform we prefer availability over consistency.

CP - Consisteny when Partition occured.

AP - Availability when Partition occured.

CA - Consistency with Availability, this is assuming we will not encounter any partition, this could be true in the case of when there is single node. This can be true for the case where our nodes are nearby, maybe in the same room.

No, System has `100%` availiability, software break easily but we can try to maximize the availability so that users don't face any outage.

In `AP` the system will get eventual consistent once the network heals.

Databases designed with traditional `ACID property` such as RDBMS choose consistency over availability, whereas system designed around `BASE philosopy`, common in NOSQL chooses availability over consistency.

The CAP theorm only true if we have large distributed system and when we have partition in network. with using superior hardware we can achieve both availability and consistency.

Some Examples of it - Spanner, cockroachDB

Import on Interaction

Jayant — Mon, 30 Jun 2025 07:24:03 +0000

WHAT

It is a performance pattern, that allows us on import things over network, on some interaction.
This can be done using React.lazy , Suspense, Dynamic Import & facade pattern.

Instead of Eager Loading (Loading resources immediately, on page load) , we load them on interaction.

Facade pattern : It is a design pattern that provides a simplified interface to a more complex subsystem. Means we mimic the UI of the deferred resource using HTML/CSS/JS.

Examples :

Showing 3rd Party Widgets : We load the 3rd party widget on interaction, initially we show a facade.
- Video Embeds
- Chat Widgets
- Social Media Widgets
Non-critical resources
- EmojiPicker: that didn't used that much.
- Filters
Authentication SDK's : Our app supports 3rd party authentication, so loading that on initial render will be a bad idea. Instead import it on interaction - Basically on button click or show a facade to the user.

Infrequently used features

Scroll to Top : Load animation libraries (e.g., react-scroll) only when the user clicks a "Back to Top" button.

const ScrollToTop = ()=>{

    const [scrollLibrary,setScrollLibrary] = useState(null);

    const handleScroll = ()=>{
        import('react-scroll').then((module)=>{
            setScrollLibrary(module);
            module.animateScroll.scrollToTop();
        })
    }

    return <>
        <button onClick={handleScroll}>Back to Top</button>
    </>
}

Export : Defer loading libraries for generating PDFs or CSVs (e.g., jsPDF) until the user clicks an export button.
Analytics : Don't preload/prefecth this as that many users don't use it.
Tabbed Interface : Load the tab component only when the user clicks a tab.


const Tab1 = React.lazy(()=>import('./Tab1));
const Tab2 = React.lazy(()=>import('./Tab2));
const tabbedInterface = ()=>{
    const [activeTab,setActiveTab] = useState(0);

    return <>
        <button onClick={()=>setActiveTab(0)}>Tab 1</button>
        <button onClick={()=>setActiveTab(1)}>Tab 2</button>
        <Suspense fallback={<div>Loading...</div>}> // In Server side use Loadable Component
            {activeTab === 0 && <Tab1 />}
            {activeTab === 1 && <Tab2 />}
        </Suspense>
    </>;
}

HOW

Facade for a `Youtube Video Embed`

const YoutubeFacade = ()=>{
    const [isEmbedLoaded,setIsEmbedLoaded] = useState(false);

    return <div classname='youtube-embed'>
        {
            !isEmbedLoaded ?
            <>
                <img
                    src={`https://img.youtube.com/vi/${videoId}/hqdefault.jpg`}
                    alt="Video thumbnail"
                    style={{ width: '100%', height: '100%' }}
                />
                <button
                    style={{
                    position: 'absolute',
                    top: '50%',
                    left: '50%',
                    transform: 'translate(-50%, -50%)',
                    padding: '10px 20px',
                    background: 'red',
                    color: 'white',
                    border: 'none',
                    }}
                >
                    Play
                </button>
        </div>
            </>:<>
                <iframe
                    width="560"
                    height="315"
                    src={`https://www.youtube.com/embed/${videoId}?autoplay=1`}
                    frameBorder="0"
                    allow="autoplay; encrypted-media"
                    allowFullScreen
                />
            </>
        }
    </div>
}

Only after the user clicks the facade does the element get added to the DOM with the.

Don't use this when

you need to do autoplay
you need that for SEO

Facade for a `Login with Google`

const GoogleLoginFacade = ()=>{
    const [isSdkLoaded,setIsSdkLoaded] = useState(false);

    const loadGoogleSDK = ()=>{
        import("./google-auth").then((module)=>{ // a new bundle is fetched with some autogenerated name, if you want a more friendly then you define its name by doing this - import(/*webpackChunkName:"google-sdk"*/ './google-auth')
            module.initGoogleSignIn();
            setIsSdkLoaded(true);
        })

    }

    return <>
        {
            !isSdkLoaded ?
            <>
                <div className='google-login-button'>
                    <button onClick={loadGoogleSDK}>Login with Google</button>
                </div>
            </>:<>
                <div id="google-signin-button" />
            </>
        }
    </>
}

// This get loaded on demand
// google-auth.js
export const initGoogleSignIn = () => {
  const script = document.createElement('script');
  script.src = 'https://apis.google.com/js/client:platform.js?onload=showLoginScreen';
  script.async = true;
  document.body.appendChild(script);
};

Reconciliation & ForwardRef In React

Jayant — Sun, 29 Jun 2025 10:24:57 +0000

Reconciliaiton in React

What

It is a mechanism to efficently update the UI by calculating the differences between Virtual DOM trees and applying only the necessary changes to the actual DOM.

The Virtual DOM trees are compared using a diffing algorithm.

For Components, the diffing algorithm compares the props and the state of the component. Basically it checks for the arguments passed to the component.
For Children, it checks if keys are same or not.
For Elements, it checks for the element type if it is changed.

Why

Updating actual DOM is expensive. So, it is better to update only the necessary changes.

Example: Suppose we have a simple Component that shows count value

function App() {
  const [count, setCount] = React.useState(0);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
  );
}

What happen state changes?

React create a new Virtaul DOM tree with the updated count value.
Compares it with the previous Virtual DOM tree.
Updates only the <p> tag.

Forward Ref

What

Forward Ref is a Higher order Component that allows a component to forward a ref that is received from parent to one of its childeren.

It is used to access the DOM element of a child component.

Why

React encapsulates components, preventing direct access to their internal DOM elements or instances. Sometimes we need to access the DOM element of a child component. For example, we want to focus on a particular element when a button is clicked or gets the value of an input field. So for that reason we use forwardRef.

It allows the parent to directly interact with the child’s DOM node or component instance.

How

Steps to use forwardRef

Create a ref object using useRef or createRef.
Pass the ref object to the Child Component.
Wrap the child component with forwardRef HOC.
The forwardRef HOC takes a render function as an argument and render function 1st argument is the props object & 2nd argument is ref.
If we don't use forwardRef HOC, we can't access the ref object.

const MyButton = React.forwardRef((props,ref)=>{
    return <button ref={ref}>
        {props.children}
    </button>
})

const buttonRef = React.useRef(null);

<MyButton ref={buttonRef}>
    Pls Click
</MyButton>

Dynamic Imports

Jayant — Sat, 28 Jun 2025 17:57:56 +0000

WHAT

It is a optimization technique that allows loading a module only when it is needed.
This decreases the initial bundle size and improves the startup time of the application.

Consider example of a Emoji Picker Component in a chat app that won't be used by many peoples.

However, there are some trade-offs to consider.

User has to wait for the module to load.
Adding additional dependency to the application @loadable/component is required for SSR as React.suspense & React.lazy are not supported.

How

1) Using React.lazy & React.suspense

Note -

Only works for CSR.
The Component you are dynamically importing must have default export.
Lazy returns a Promise that resolves to a module.

import React, { Suspense } from 'react';

const EmojiPicker = React.lazy(()=>import("./emojiPicker.tsx"));

function MyComponent() {
  return (
    <div>
      <Suspense fallback={<div>Loading...</div>}>
        <EmojiPicker />
      </Suspense>
    </div>
  );
}

2) Using @loadable/component

yarn add @loadable/component

The syntax is similar we just have to pass the fallback UI in the loadable function only.
Also it works with Suspense also but as suspense didn't work in SSR use carefully.

import React, { Suspense } from 'react';
import loadable from "@loadable/component";

const EmojiPicker = loadable(()=>import("./emojiPicker.tsx"),{
    fallback:<div>Loading...</div>
});

function MyComponent() {
  return (
    <div>
        <input type="text" placeholder="Type a message..." />
        {openEmojiPicker && <EmojiPicker />}
    </div>
  );
}

Bundle Splitting

Jayant — Mon, 23 Jun 2025 15:18:19 +0000

WHAT

It is a technique to split the larger javascript bundle into smaller bundles. This is done to reduce the initial load time of the application.

Normally, whole JS Bundle is loaded at once. So the Initial Load Time is high. This is because the browser has to download the big bundle , parse it and then execute it.

WHY

There are certain parts/components of your website, that are used rarely or used conditionally. So its not a good idea to load them initially and then they are not needed.

So in bundle splitting, we split the bundle into smaller bundles and they loaded on-demand.

There will be a main.bundle.js which will be loaded first and then the other bundles will be loaded on-demand.

Bundle Splitting also decrease the FCP (First Contentful Paint) time and TTL(Time to Interactive) time.

BENEFITS

Reduce the Initial Load Time
Improved UX

HOW

To do this we can use the module bundlers like webpack or rollup or parcel etc.

Dynamic Imports : Use Dynamic Imports to split code at specific time.
Route-Based Code Splitting : Use this to split code based on the route.
Lazy Loading : Use this to load the code only when it is needed.

BONUS

FCP(First Contentful Paint) : It is a metric that measures the time it takes until first content is shown.
- After FCP user sees the content but it is not interactive.
LCP(Largest Contentful Paint) : It is a metric that measures the time it takes until the largest content is shown.
TTL(Time to Interactive : It is a metric that measures the time it takes for the page to become responsive.

Scale APP using Dependency Inversion Principle

Jayant — Sun, 22 Jun 2025 06:44:32 +0000

What is DIP?

Dependency Inversion Principle is one of the SOLID Principle.

It states that High Level Module shouldn't depend on low level modules, Both should depend on abstraction.

Means, the code that handles business-logic shouldn't depend directly on the implementation details. Instead they both should depend on interfaces/abstract Class.

Example

Suppose we have to 2 Modules,Car Module and Engine Module and Car Module uses Engine Module. Now if we are using DIP then we can swap Diesal Engine to Petrol Engine. Otherwise I have to make changes in the Car Module also.

HOW

We can do this using either interface injection or abstract class injection.
Interfaces doesn't exist at runtime, so in NestJS we attach a token to the Service we want to inject in the service.

Using Interface Injection

interface IPlanService {
  canReview(): boolean;
}

export PlanService implements IPlanService {
    canReview():boolean{
        return true;
    }
}


// Review.module.ts
const PLAN_SERVICE = Symbol('PLAN_SERVICE');

@Module({
    providers: [
        {
            provide:PLAN_SERVICE
            useClass:PlanService,
        }
    ]
)
export class ReviewModule {}

// Now we can inject the `PlanService` in the `ReviewService` using `Inject` decorator.

@Injectable()
export class ReviewService {
    constructor(@Inject(PLAN_SERVICE) private planService: IPlanService) {}
}

Using Abstract Class Injection

abstract class PlanServiceContract{
    abstract canReview():Promise<boolean>;
}

export class PlanService implements PlanServiceContract{
    async canReview():Promise<boolean>{
        return true;
    }
} 

// Review.module.ts
@Module({
    providers: [
        {
            provide:PlanServiceContract, // class itself as token
            useClass:PlanService,
        }
    ],
    exports:[
       PlanServiceContract, 
    ]
)
export class ReviewModule {}

// Use it like this 
@Injectable()
export class ReviewService {
    constructor( private planService: PlanServiceContract) {}
}

We don't have to create a token if we are using abstract Class.

WHEN

You can use it everywhere, but it will be overkill and slows the development time.

When to use it :

For Shared Providers
Integration - External API's (Stripe, Github, etc.)
For Repositories , to mock DB or replace DB
Core Features that can scale in future / Business Logic.

The benefits of doing this is that it give us capability to mock things during test and change the behaviour without making changes in other modules. Its best to keep your Modules DeCoupled.

TIPS

Create a Single Abstract File at the module lvl, that contains all the abstract classes.
Use Base Interface / Abstract Class.

N+1 Query Problem

Jayant — Sat, 21 Jun 2025 10:23:42 +0000

What

When we make N+1 Query to the Database instead of 1 single optimized query.

Examples

1 Getting ALL User Blog Posts

// Getting all the users 
const users = await User.find();

// Looping through all the users and getting the posts
for(const user of users){
    user.posts = await Post.find({userId: user.id}))
}

2 Fetching Subscription for Multiple Orgs

const orgs = await Org.find();

for(const org of orgs){
    orgs.subscription =  await Subscription.find({orgId: org.id});
}

As you can see in the above examples, we are making N+1 queries to the database.

1 - Query to get all the users

N - Queries to get all the posts for each user

Solution

We can optimize above query by using Aggregation and Lookup to get all the posts for each user in single query.

// For MongoDB
const users = await this.userModel.aggregate([
    {
        $match:{
            _id: userId
        }
    },{
        $lookup: {
            from: "posts",
            localField: "_id",
            foreignField: "userId",
            as: "posts"
        }
    }
])

Same way we can do this in SQL using Joins

// Left Outer Join - Keeps all the rows from the left table even if there is no matched data in the right table, NULL is shown from Right Table
// Inner Join - Only matched rows are shown
// FULL Join - ALL rows from both table.
SELECT * FROM orgs LEFT JOIN subscriptions ON orgs.id = subscription.orgId;

Token Bucket Algorithm

Jayant — Mon, 16 Jun 2025 08:04:31 +0000

These Algo. typically used as Rate limiting Algorithm.
It is used to control amount of data or number of requests that can be proccessed in a given time period.

WORKING :

Token are added to the Bucket at a fixed rate.
The Bucket has a Max. Capacity, it can't hold more tokens than that.
When a Request came, the Bucket is checked for number of token available
- If req. tokens are available then remove that tokens from the bucket and process the request.
- If no token are available, the request is rejected or pushed to a retry queue.

IMPLEMENTATION :

Token Bucket can be implemented in respect to user or application.
Means either we can use it rate limit the user, that a certain user can only make 10req/sec.
or we can use it to rate limit the application, that a certain application can only make 10req/sec.

class TokenBucket{
    private refillRate:number;  // no of token added to the bucket per second
    private capacity:number;
    private Bucket: number;
    private lastRefillTime: number;

    constructor(refillRate:number,capacity:number){
        this.refillRate = refillRate;
        this.capacity = capacity;
        this.Bucket = capacity;
        this.lastRefillTime = Date.now();
    }

    public refill(){
        const time = Date.now();
        const diff = time - this.lastRefillTime;
        const tokensToAdd = Math.floor(diff* this.refillRate);
        this.Bucket = min(this.capacity, this.Bucket+tokensToAdd);
        this.lastRefillTime = time;
    }

    public allowRequest(){
        // Update the Bucket with tokens
        refill();

        if(this.Bucket >= 1){
            this.Bucket = this.Bucket - 1;
            return true;
        }

        return false;
    }
}

Example : LIMITING REQUESTS PER SECOND FOR USER IN NESTJS

FLOW

Client ──> NestJS API (Producer)
               └── always send to RabbitMQ ➤ (free or premium queue)

Worker (Consumer)
    └── Pull from queue(s)
        └── Check Redis token bucket
            ├── ✅ Allowed → process job
            └── ⛔ Not allowed → requeue with delay

AWS Roles & Elastic IP

Jayant — Sun, 15 Jun 2025 09:40:38 +0000

AWS Roles

What

They are set of permissions that are attached to the AWS Resource.

You can attach multiple roles to a single AWS resource.

Why

Normal way to give permissions to AWS resources is to create IAM user and attach policies to it, But this also exposes our credentials also.
The credentials are stored in that EC2 instance and can be accessed.
Also they are long lived, can't rotate them.

So we create a IAM role and attach policies to it.

Consider role as clothes and resources as user.
user can wear the clothes and easily remove them.

How

Create IAM Role
Attach policies to the role
Attach the role to a any AWS Resources.

For Examples: You want that your EC2 instance is able to access your S3 bucket.
Create a IAM Role - S3-Ec2Access
Attach the policy AmazonS3FullAccess to the role.
Attach the role to the EC2 instance under security.

Same way you can create IAM Roles for other AWS resources.

Some usecases are
1) Lambda → Write logs to CloudWatch and push to SQS
2) Developers, apps, or scripts need temporary credentials with limited access
3) CI/CD tools like GitHub Actions, CodeBuild, GitLab CI, Jenkins, etc., assume IAM roles to deploy infrastructure or applications.
4) Give external SaaS services secure access to your AWS account (e.g., monitoring, cost tracking, backups)
5) Cross-account access : allowing users, roles, or services in one AWS account (Account A) to securely access resources in another AWS account (Account B).

AWS Elastic IP

An Elastic IP is an static public IPv4 address(32-bit number), that we can attach to an EC2 instance, it helps maintain a consitent IP Address even if our EC2 instance restarts or changes.

When we create an EC2 instance, we get a dynmaic IP Address that will change if we stop&start the instance.
But we want to maintain a consistent IP Address so we use Elastic IP.

Elastic IP is attached to the EC2 instance.

It is free until it is attached to some EC2 instance.

If you are using a Load Balancer Service then you don't need to attach Elastic IP to the EC2 instance, cuz LoadBalancer manages IP Internally.

Cron Jobs in Nest JS

Jayant — Sat, 14 Jun 2025 09:33:51 +0000

Cron Jobs are scheduled Tasks that runs automatically at a specified time.
They are commonly used for these works.

Running Backups at MIDNIGHT
Sending Email Reports

They use Cron Expressions that defines when the job should run.

// Format - they are either 5 or 6 fields
*     *     *     *     *     *
│     │     │     │     │     │
│     │     │     │     │     └─ Day of Week (0 - 6) (Sunday to Saturday)
│     │     │     │     └────── Month (1 - 12)
│     │     │     └──────────── Day of Month (1 - 31)
│     │     └────────────────── Hour (0 - 23)
│     └──────────────────────── Minute (0 - 59)
└────────────────────────────── (optional) Seconds (0 - 59)

To make a Cron Expression you can go to Cron Tab Guru.

* * * * * *  - RUNS EVERY Seconds

* * * * * 1 - RUNS EVERY Second on Monday

0 1 * * * 1 - RUNS at past midnight every Monday

0 */1 * * * 1  - RUNS every 1 minute on Monday

we don't need to memorize them, we can use Corn Expression Enums to make it easier.

How & Where to Run it

we can run it in our server or we can use serverless Cron Jobs provided by Cloud Providers.

To Run Cron Job in Node.js

// In Express
// Install the `node-cron` package
import cron from 'node-cron';

cron.schedule('0 0 * * *', () => {
  console.log('Running task at midnight');
});

//  In NestJS
// install @nestjs/schedule package


// Inside app.module register your Schedule Module, it initialize and registers any cron job in our app,

import { Module } from '@nestjs/common';
import { ScheduleModule } from '@nestjs/schedule';

@Module({
  imports: [
    ScheduleModule.forRoot()
  ],
})
export class AppModule {}


// To create a Cron JOb we need to attach @Cron() decorator to the handler
//  Using CronExpressionEnums
import { Injectable, Logger } from '@nestjs/common';
import { Cron, CronExpression } from '@nestjs/schedule';

@Injectable()
export class TasksService {
  private readonly logger = new Logger(TasksService.name);

  @Cron(CronExpression.EVERY_30_SECONDS)
  handleCron() {
    this.logger.debug('Called every 30 seconds');
  }
}


//  If any exception occurs it will be logged in the console, as every method annoted with @Cron is automatically wrapped in try-catch block.
// We can also gives additional options to the @Cron decorator
import { Injectable, Logger } from '@nestjs/common';
import { Cron, CronExpression } from '@nestjs/schedule';

@Injectable()
export class TasksService {
  private readonly logger = new Logger(TasksService.name);

  @Cron(CronExpression.EVERY_30_SECONDS, {
    name: 'my-cron-job',
    timeZone: 'Asia/Kolkata',
  })
  handleCron() {
    this.logger.debug('Called every 30 seconds');
  }
}

In NestJS we can access the cron job once it is declared & also create it dynamically.

If we want to control a cron job we should give it a name.

To access & dynamically create the cron job using SchedulerRegistry.


const job = this.schedulerRegistry.getCronJob('notifications');

job.stop();
console.log(job.lastDate());

We can also add a cron job dynamically.

addCronJob(name: string, seconds: string) {
  const job = new CronJob(`${seconds} * * * * *`, () => {
    this.logger.warn(`time (${seconds}) for job ${name} to run!`);
  });

  this.schedulerRegistry.addCronJob(name, job);
  job.start();

  this.logger.warn(
    `job ${name} added for each minute at ${seconds} seconds!`,
  );
}

Cron Jobs can be both async and sync, Also they are used to run specific task at specific time.
If we want to run some task , Every X milliseconds like Polling, health checks, repeated tasks. Then we can use @Interval.

// similar to setInterval in nodejs
@Interval(10000) // Every 10 seconds
handleInterval() {
  console.log('Polling external service...');
}

Also we have Timeout similar to setTimeout, they are used when we want to run a task once but after a delay.

Running a task once after app startup
Delaying execution of a retry or follow-up task
Debouncing logic (in rare backend scenarios)

@Timeout(5000) // After 5 seconds
handleTimeout() {
  console.log('Initial sync task after startup delay');
}

They both can be called dynamically using SchedulerRegistry.

if you have set Cron Job to run EVERY_10_MINUTE, then it will run in every multiple of 10.

DEV Community: Jayant

you can prove you know a secret without ever revealing it. no, seriously. the math actually works. wrote a breakdown of how ZK proofs work

ZK from Scratch #1: What is a Zero-Knowledge Proof?

ZK from Scratch #1: What is a Zero-Knowledge Proof?

TL;DR

What is a Zero-Knowledge Proof?

Why does this matter?

How does it work? The Three Properties

The Alibaba's Cave Protocol

The Non-Transferability Property

Quick Test: ZK or Not ZK?

Why One Random Check Is Enough

What's Next

CAP Theorm

No, System has 100% availiability, software break easily but we can try to maximize the availability so that users don't face any outage.

In AP the system will get eventual consistent once the network heals.

Databases designed with traditional ACID property such as RDBMS choose consistency over availability, whereas system designed around BASE philosopy, common in NOSQL chooses availability over consistency.

The CAP theorm only true if we have large distributed system and when we have partition in network. with using superior hardware we can achieve both availability and consistency.

Import on Interaction

WHAT

HOW

Facade for a Youtube Video Embed

Facade for a Login with Google

Reconciliation & ForwardRef In React

Reconciliaiton in React

What

Why

Forward Ref

What

Why

How

Dynamic Imports

WHAT

How

Bundle Splitting

WHAT

WHY

HOW

BONUS

Scale APP using Dependency Inversion Principle

What is DIP?

Example

HOW

Using Interface Injection

Using Abstract Class Injection

WHEN

TIPS

N+1 Query Problem

What

Solution

Token Bucket Algorithm

WORKING :

IMPLEMENTATION :

Example : LIMITING REQUESTS PER SECOND FOR USER IN NESTJS

AWS Roles & Elastic IP

AWS Roles

What

Why

How

AWS Elastic IP

Cron Jobs in Nest JS

How & Where to Run it

No, System has `100%` availiability, software break easily but we can try to maximize the availability so that users don't face any outage.

In `AP` the system will get eventual consistent once the network heals.

Databases designed with traditional `ACID property` such as RDBMS choose consistency over availability, whereas system designed around `BASE philosopy`, common in NOSQL chooses availability over consistency.

Facade for a `Youtube Video Embed`

Facade for a `Login with Google`