Quick snapshot

• Type: 100% Book Built Issue (Fresh Issue only)
• Fresh issue: Up to 2,35,00,000 equity shares (FV ₹2 each); no OFS
• Price band: ₹56 — ₹61 per share
• Issue size (gross): ₹143.35 crore (at upper band)
• Lot size: 235 shares
• Reservations: Up to 1,64,500 shares for Employees; up to 3,29,000 shares for Eligible Shareholders of Dev Information Technology Limited
• Listing: NSE and BSE (NSE designated)
• Key dates: Anchor 9 Sep 2025; Bidding 10–12 Sep 2025; UPI mandate by 5 PM on close day

What the company does (in plain words)

• DevX operates flexible workspaces: coworking desks and managed office spaces; also offers allied services (e.g., payroll management, value-added services).
• Revenue mix is dominated by flexible office spaces; scale-up driven by new centers and higher occupancy under straight-lease and revenue-share models.

Use of proceeds (Objects of the Issue)

Proposed use of Net Proceeds (deployment to complete by FY26/27; GCP ≤25% of Gross Proceeds):

• ₹73.12 crore for fit-outs in 4 Proposed Centers under the straight-lease model (₹731.16 million)
• ₹35.00 crore for repayment/prepayment of borrowings and redemption of non-convertible debentures (₹350.00 million)
• Balance for General Corporate Purposes (within SEBI limit)
• Monitoring and interim use per RHP; no external appraisal of objects

Financial highlights (Consolidated)

• Revenue from operations:
• FY23: ₹69.91 crore (₹699.11 million)
• FY24: ₹108.09 crore (₹1,080.87 million)
• FY25: ₹158.88 crore (₹1,588.75 million)
• EBITDA margin (%): FY23 42.74; FY24 59.90; FY25 50.64
• Profit after tax (₹ crore): FY24 ₹0.44; FY25 ₹1.77 (PAT margin low; FY23 had losses per RHP ratio table)
• Operating cash flow (₹ crore): FY23 ₹26.48; FY24 ₹7.56; FY25 ₹93.75
• Note: FY25 OCF is strong despite modest PAT, implying working-capital movements/advances supported cash generation.

Capital structure and share count

• Face value: ₹2 per share
• Pre-issue paid-up equity share capital (FY25): ₹169.15 million (₹16.915 crore)
• Shares outstanding (pre-issue): ≈ 8.4575 crore (84,575,000) at FV ₹2
• Fresh issue shares: 2.35 crore (23,500,000)
• Shares outstanding (post-issue): ≈ 10.8075 crore (108,075,000)
• Promoter & Promoter Group holding: 3,32,01,850 shares (49.80%) pre-issue; inferred ~30.72% post-issue on expanded base
• Customer concentration: top-10 and related-party contributions are meaningful

Valuation (at the price band)

Market cap (post-issue):

• At ₹56: ≈ ₹605.22 crore
• At ₹61: ≈ ₹659.26 crore

FY25 Revenue: ₹158.88 crore; EBITDA margin 50.64% → EBITDA ≈ ₹80.45 crore

P/S (FY25):

• At ₹56: ≈ 3.81x
• At ₹61: ≈ 4.15x

EPS (FY25):

• PAT ₹1.77 crore on post-issue shares (10.8075 cr) → EPS ≈ ₹0.164
• P/E (post-issue): ~341x at ₹56; ~372x at ₹61
• For reference, on pre-issue shares (8.4575 cr), EPS ≈ ₹0.210 → P/E ~267x–291x
• EV-based metrics: Pending net debt/lease liability details; EV/Revenue and EV/EBITDA likely more meaningful than P/E given depreciation/finance costs.

Valuation — EV snapshot

• FY25 borrowings: ~₹130.67 crore; Cash & cash equivalents: ~₹3.36 crore → Net debt: ~₹127.31 crore
• Lease liabilities (FY25): ~₹254.91 crore (Ind AS 116)
• EBITDA FY25: ~₹80.49 crore (50.64% margin on ₹158.88 crore revenue)

EV (ex-lease):

• At ₹56: EV ≈ ₹732.53 cr → EV/Revenue ≈ 4.61x; EV/EBITDA ≈ 9.10x
• At ₹61: EV ≈ ₹786.57 cr → EV/Revenue ≈ 4.95x; EV/EBITDA ≈ 9.77x

EV (incl. lease liabilities):

• At ₹56: EV ≈ ₹987.44 cr → EV/Revenue ≈ 6.21x; EV/EBITDA ≈ 12.27x
• At ₹61: EV ≈ ₹1,041.48 cr → EV/Revenue ≈ 6.56x; EV/EBITDA ≈ 12.94x

Pro forma (ex-lease) after planned ₹35.00 cr debt repayment from Net Proceeds:

• At ₹56: EV ≈ ₹697.53 cr → EV/Revenue ≈ 4.39x; EV/EBITDA ≈ 8.67x
• At ₹61: EV ≈ ₹751.57 cr → EV/Revenue ≈ 4.73x; EV/EBITDA ≈ 9.34x

Peer comparison snapshot (FY25 basis, from RHP)

Listed peers: Awfis Space Solutions, Smartworks Coworking Spaces, Indiqube Spaces

• Scale: DevX (₹158.88 cr revenue) vs Awfis (₹1,207.5 cr), Smartworks (₹1,374.1 cr), Indiqube (₹1,059.3 cr) → DevX ~1/7th to 1/9th the scale
• EBITDA margin: DevX 50.64% vs Awfis 35.40%, Smartworks 62.39%, Indiqube 58.20% → DevX in line with efficient peers
• Revenue CAGR (FY23–25): DevX 50.75% vs Awfis 48.81%, Smartworks 38.98%, Indiqube 35.17% → DevX shows fastest growth
• Occupancy: DevX 87.61% vs Awfis 83.04%, Smartworks 83.12%, Indiqube 85.12% → DevX leads on utilization
• Center count: DevX 26 centers vs Awfis 208, Smartworks 46, Indiqube 105 → DevX smallest but highest per-center productivity
• P/E context: Awfis posted profit (₹67.87 cr PAT), others losses; DevX modest ₹1.77 cr PAT → P/E optically high but growth trajectory strong

Takeaway: DevX trades at premium to revenue (EV/Rev ~4.4x–4.7x vs peers likely lower) but justified by superior margins, occupancy, and growth. Watch for scale-up execution and margin sustainability.

File upload and validation can get tricky when it comes to FastAPI as we simply cannot use pydantic to do validations for us. Let’s see how to get this done.

First of all we need to install python-multipart . With a simple command

pip install python-multipart

This is because upload files are sent as form data.

from fastapi import UploadFile

@app.post("/file")
def upload_file(file: UploadFile):
    validate_file_size_type(file)

    return {
        "filename": file.filename,
        "content_type": file.content_type,
    }

Here I have a simple function which takes a file as a parameter. Since we have typed it as UploadFile, the request body has to be sent as multipart/form-data. Now let's check out our validate_file_size_type function.

from fastapi import HTTPException, status
from typing import IO
import filetype


def validate_file_size_type(file: IO):
    FILE_SIZE = 2097152 # 2MB

    accepted_file_types = ["image/png", "image/jpeg", "image/jpg", "image/heic", "image/heif", "image/heics", "png",
                          "jpeg", "jpg", "heic", "heif", "heics" 
                          ] 
    file_info = filetype.guess(file.file)
    if file_info is None:
        raise HTTPException(
            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
            detail="Unable to determine file type",
        )

    detected_content_type = file_info.extension.lower()

    if (
        file.content_type not in accepted_file_types
        or detected_content_type not in accepted_file_types
    ):
        raise HTTPException(
            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
            detail="Unsupported file type",
        )

    real_file_size = 0
    for chunk in file.file:
        real_file_size += len(chunk)
        if real_file_size > FILE_SIZE:
            raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Too large")

In this function, we are validating if the file is of type image. Note that we are not just checking the extension of the file name as it can be changed. You can change the list for the expected file type like application/json for JSON files.

So, here’s the thing, a file is not completely sent to the server and received by your FastAPI app before the code in the path operation starts to execute.

So, you don’t have an actual way of knowing the actual size of the file before reading it.

You can check out this GitHub discussion for deeper understanding https://github.com/tiangolo/fastapi/issues/362

from typing import Generic, List, TypeVar

from pydantic import BaseModel, conint
from pydantic.generics import GenericModel


class PageParams(BaseModel):
    page: conint(ge=1) = 1
    size: conint(ge=1, le=100) = 10


T = TypeVar("T")


class PagedResponseSchema(GenericModel, Generic[T]):
    """Response schema for any paged API."""

    total: int
    page: int
    size: int
    results: List[T]

First, we declare the pydantic schema for request and response. Here conint (constrained int) is used which does validation checks.

PagedResponseSchema is a generic pydantic model which takes any other pydantic model and puts it in results values as a list.

from fastapi import FastAPI, Depends, Request, Query
from pagination import PagedResponseSchema, PageParams, paginate
from pydantic import BaseModel
from sqlalchemy.orm import Session
from db import get_db
from user import User

app = FastAPI()

class UserSchema(BaseModel):
    id: int
    name: str

    class Config:
        orm_mode = True

@app.get("/users", response_model=PagedResponseSchema[UserSchema])
def get_users(request: Request, page_params: PageParams = Depends(), db: Session = Depends(get_db)):

    # # Add 1000 users to the database

    # for i in range(1000):
    #     db.add(User(id=i, name=f"User {i}"))
    
    # db.commit()

    query = db.query(User)

    return paginate(page_params, query, UserSchema)

Next we have our main.py file where our fastAPI server will be running.

In UserSchema we have added orm_mode: True which will take sql ORM model and converts it into pydantic schema. It also does many fancy things you can read in docs

After that one key point to note is how the page_params is declared. This way it is interpreted as query params and not as request body.

Now time for our special sauce paginate function.

def paginate(page_params: PageParams, query, ResponseSchema: BaseModel) -> PagedResponseSchema[T]:
    """Paginate the query."""

    paginated_query = query.offset((page_params.page - 1) * page_params.size).limit(page_params.size).all()

    return PagedResponseSchema(
        total=query.count(),
        page=page_params.page,
        size=page_params.size,
        results=[ResponseSchema.from_orm(item) for item in paginated_query],
    )

This function is not that trivial, it just takes params and query and then adds offset and limit to that query. Now since ORM does lazy loading the call to the database has not happened yet that’s why we can add limit and offset values.

And voila! Your performant pagination API is ready.

You can find sample code on github https://github.com/jayhawk24/pagination-fastapi . Feel free to follow me on github

Originally published at https://jayhawk24.hashnode.dev.

Auto fix lint errors like spacing, sorting imports and much more, let Github Actions create a commit for you fixing them.

If you want to fix lint errors running on CI you can easily commit all changes that the linter has made.

In this example, I will be using black and isort to lint a python repo and sort the imports in the correct order also removing any unused imports.

name: Lint

on:
  pull_request:
    branches: ['*']

jobs:
  run-linters:
    name: Run linters
    runs-on: ubuntu-latest

    steps:
      - name: Check out Git repository
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v1
        with:
          python-version: 3.8

      - name: Install Python dependencies and run linters
        # Here you can use your own linter commands
        run: |
          pip install black isort
          black .
          isort --profile black --sg="app/alembic/**"  .

      - name: Run linters
        uses: stefanzweifel/git-auto-commit-action@v4
        with:
          commit_message: 'Applied automatic fixes from linters'
          github_token: ${{ secrets.GITHUB_TOKEN }}

Applying to jobs can be a tedious job why not let a bot handle it?

I personally love Instahyre as they don’t ask any follow-up questions and it’s just one click to apply.

So let’s use python to do this instead.

from selenium import webdriver
from selenium.webdriver.common.by import By
import time


# configure your email and password here
email = "youremail@example.com"
password = "yourpass"

# create a new browser instance
driver = webdriver.Firefox()

# navigate to the website
driver.get("https://www.instahyre.com/")

# locate the login button and click on it
login_button = driver.find_element(By.XPATH, "//a[@href='/login/']")
login_button.click()

# locate the email and password fields and enter the values
email_field = driver.find_element(By.ID, "email")
email_field.send_keys(email)
password_field = driver.find_element(By.ID, "password")
password_field.send_keys(password)

# locate the submit button and click on it
submit_button = driver.find_element(By.XPATH, "//button[@type='submit']")
submit_button.click()

# wait for 3 seconds after login
time.sleep(3)

# locate the first view button and click on it
view_button = driver.find_elements(By.XPATH, "//button[contains(text(), 'View')]")[0]
view_button.click()

# wait for 3 seconds
time.sleep(3)

# number of applications to be sent
t = 1000
while t > 0:
    try:
        # locate the apply button and click on it
        apply_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Apply')]")
        apply_button.click()
    except:
        print("Apply button not found.")
    # wait for 1 seconds
    t -= 1
    time.sleep(1)

driver.quit()

In order to run this script all you need is to install python

Create a virtual environment and set it up

python3 -m venv env
source env/bin/activate

then use pip to install the requirements with

pip install -r requirements.txt

#requirements.txt file

async-generator==1.10
attrs==22.2.0
black==22.12.0
certifi==2022.12.7
cffi==1.15.1
click==8.1.3
colorama==0.4.6
exceptiongroup==1.1.0
h11==0.14.0
idna==3.4
mypy-extensions==0.4.3
outcome==1.2.0
pathspec==0.10.3
platformdirs==2.6.2
pycparser==2.21
PySocks==1.7.1
selenium==4.7.2
sniffio==1.3.0
sortedcontainers==2.4.0
tomli==2.0.1
trio==0.22.0
trio-websocket==0.9.2
urllib3==1.26.14
wsproto==1.2.0

Now all you need to do is to enter your email and password and run the script

python ./main.py

Using refs we can invoke methods of child components from parent in both class components as well as in functional components. This is just a workaround, recommended way is to lift the state up to parent then pass it through props to child component or with context API.

Let’s use a simple example of a counter.

import React, { useState } from "react";

const Child = () => {
  const [count, setCount] = useState(0);

  return <div>Child counter {count}</div>;
};

export default Child;

And our Parent component looks like this where it has a button and renders the child component as well.

const Parent = () => {
  const handleUpdate = () => {};
  return (
    <div>
      <h1>Parent</h1>
      <Child />
      <button onClick={handleUpdate}> Update Count </button>
    </div>
  );
};

Now on button click we want on increase the count in child component. We can do this using refs. Let’s modify our child component first.

const Child = forwardRef((props, ref) => {
  const [count, setCount] = useState(0);

  useImperativeHandle(ref, () => ({
    handleInc() {
      setCount(count + 1);
    }
  }));

  return <div>Child counter {count}</div>;
});

export default Child;

React.forwardRef creates a React component that forwards the ref attribute it receives to another component below in the tree.

useImperativeHandle customizes the instance value that is exposed to parent components when using ref. As always, imperative code using refs should be avoided in most cases. useImperativeHandle should be used with forwardRef

Now in parent component we just have to create a ref and pass it to child component as props.

const Parent = () => {
  const childRef = createRef();

  return (
    <div>
      <h1>Parent</h1>
      <Child ref={childRef} />
      <button onClick={() => childRef.current.handleInc()}>Update Count</button>
    </div>
  );
};

Another pattern with class components we can use this in child components.

class Child extends Component {
  constructor() {
    super();
    this.state = {
      count: 0
    };
    this.handleInc = this.handleInc.bind(this);
  }

  handleInc() {
    this.setState({ count: this.state.count + 1 });
  }

  render() {
    return <div>Count: {this.state.count}</div>;
  }
}

If you want to play around https://codesandbox.io/s/silly-montalcini-1iimot