Python Developer

Python Developer
Location: Ahmedabad (on-site)
Type: Full-time
Experience: 1- 5 years

To Apply fill in the Microsoft form: https://forms.cloud.microsoft/r/XktwFdpf2w
__________________________________________________
About the Role

We are a proprietary quantitative trading firm focused on Indian and global equity, derivatives,
and cryptocurrency markets. Our research and trading depend on data being correct, complete,
reproducible and available on time. This role owns the programs and processes that make that
possible.
You will build and maintain Python programs that collect data from broker and exchange APIs,
third-party market-data vendors, public sources and internal files, clean and reconcile it, and
manage storage in ClickHouse, PostgreSQL and Parquet. You will preserve point-in-time versions
so research can reproduce the information available on a historical date, and keep scheduled
and continuously running processes reliable on Linux.
Strong, hands-on Python programming is essential . you must be able to write, debug and
maintain the underlying code yourself. Experience limited to configuring managed platforms,
assembling graphical workflows or writing SQL in database clients is insufficient. Financial-
market knowledge is preferred.
Responsibilities -
Data ingestion. Build and maintain Python programs integrating REST APIs and WebSocket
feeds from brokers, exchanges and data vendors, along with websites and structured files.
Handle scheduled downloads, continuous collection, pagination, rate limits, retries,
reconnections and recovery of missing data.
Vendor and broker API management. Handle authentication and API keys, token and
session lifecycles, permissions and entitlements, subscription limits and IP restrictions. Work
around undocumented behaviour and keep integrations running when a provider changes
its interface or access rules without notice.
Cleaning and reconciliation. Resolve differences in schemas, identifiers, symbol
conventions, timestamps and timezones using pandas and NumPy. Maintain instrument
mappings across sources, and investigate inconsistent prices, corporate-action adjustments,
missing observations and source disagreements.
Storage design. Work with ClickHouse, PostgreSQL, Parquet and CSV through connectors
such as psycopg2, asyncpg, SQLAlchemy, clickhouse-connect and pyarrow. Choose
schemas, keys, partitions, indexes and query patterns suited to large time-series datasets,
and manage memory and performance as volumes grow.
Point-in-time versioning. Retain original values and later revisions with the timestamps and
source information needed to establish when each became available, supporting retrieval of
both the latest data and the information available at a historical decision time.
Backfills and reprocessing. Recover historical gaps and regenerate datasets when source
data or processing logic changes, without breaking reproducibility or conflicting with
ongoing updates.
Data quality and monitoring. Detect duplicates, stale feeds, missing timestamps,
unexpected values and incomplete responses, and make failures visible through useful logs,
alerts and status information.
Internal tools. Build Python utilities, scripts and simple graphical interfaces for recurring
internal tasks that team members need to run without writing code, packaged as standalone
applications where useful. Requirements often arrive informally and partially specified, so
the work includes clarifying what is actually needed.
Data-access interface. Maintain a consistent Python interface giving research and trading
systems a standard way to retrieve live and historical data, reducing duplicated cleaning
logic.
Reliability on Linux. Manage scheduling, process supervision, structured logging and log
rotation. Diagnose failures and ensure retries, restarts and reconnections do not silently lose
or duplicate data.
Maintenance and collaboration. Investigate unfamiliar programs, resolve bugs and
performance problems, translate requirements from quant team members into
maintainable programs, and document procedures, dependencies, provider behaviour and
known issues.
What We Expect
Relevant professional Python experience building and maintaining substantial programs
used in a working environment.
Strong core Python. Data structures, object behaviour, iterators, generators, exceptions,
context managers, modules, and appropriate use of functions and classes. You must be able
to independently write, explain, debug and maintain code.
Command of the Python ecosystem. pandas and NumPy for real processing, the standard
library (datetime, itertools, functools, logging, pathlib, json, typing, asyncio,
multiprocessing, threading, concurrent.futures), and common libraries for HTTP,
WebSocket, parsing, validation and testing, with an understanding of their limitations.
Third-party API integration. Working against interfaces you do not control: authenticated
and rate-limited APIs, streaming connections, paginated historical endpoints, incomplete
documentation, credential and session expiry, provider outages and breaking changes.
Database and SQL ability. Programmatic access from Python including parameterised
queries, transactions, bulk inserts and connection handling, plus joins, analytical queries and
investigating slow or incorrect results.
Real dataset experience. Inconsistent schemas, missing values, duplicates and unexpected
upstream changes, with efficient use of vectorised operations, dtypes, chunked reads and
columnar formats where data does not fit in memory.
Concurrency and performance judgment. When to use threads, async I/O or
multiprocessing, how the GIL affects the workload, and how to control memory and shared-
state problems.
Operational understanding. Timeouts, partial responses, rate limits, idempotency and safe
recovery, including what happens when a process stops halfway through its work.
Linux confidence. Inspecting processes and logs, managing scheduled jobs, diagnosing
resource issues and running programs outside an interactive notebook.
Version control and project practices. Git for tracking changes, branching and history, plus
proper project structure, configuration and credentials kept out of code, virtual
environments and pinned dependencies.
Validation and debugging habits. Checking data correctness as well as whether a program
runs, using tests and reconciliation checks, and being able to explain how you verified a fix.
Preferred Experience
Financial-market data, instruments, trading sessions, corporate actions and market
conventions.
Broker, exchange or market-data vendor APIs, including historical downloads and live feeds.
WebSocket collectors, streaming ingestion, out-of-order events and gap recovery.
ClickHouse, PostgreSQL, Parquet and large-scale time-series storage.
Point-in-time datasets and internal Python libraries used by other team members.
Internal tools or interfaces built for non-developers, including packaged applications.
Profiling, memory optimisation and libraries such as polars, numba or Cython where
justified.
What This Role Is Not
A web-development role. Websites, frontend features, CRUD applications and standard
Django/FastAPI endpoints are not the work.
A BI or reporting role. Dashboards, visualisation tools and Excel reporting are not the
deliverables.
A platform-configuration role. Managed ETL platforms, graphical workflows and notebook
services do not substitute for implementing the logic in Python.
A SQL-only or database-operator role. SQL matters, but the position requires ownership of
the Python programs that acquire, validate, transform and deliver the data.
A cloud architecture or DevOps role. Linux operations support the systems you build;
infrastructure and deployment tooling are not the focus.