results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

z = (x - x.rolling(60).mean()) / x.rolling(60).std()

bt = Backtest(strategy, data, fees=0.0002)

@dataclass

X = sm.add_constant(features)

import pandas as pd

for t in range(lookback, len(df)):

assert not df.index.duplicated().any()

await self.risk.check(order)

log.info('rebalance', n=len(weights))

σ² = E[(X − μ)²]

β = cov(r, m) / var(m)

p_value = stats.ttest_1samp(r, 0).pvalue

corr = np.corrcoef(a, b)[0, 1]

signal = np.sign(z).shift(1)

results = bt.run(walk_forward=True)

class Order: side: str; qty: float

model = sm.OLS(y, X).fit()

returns = prices.pct_change().dropna()

pnl[t] = pos[t-1] * ret[t]

drawdown = equity / equity.cummax() - 1

half_life = -np.log(2) / λ

import numpy as np

∑ wᵢ = 1, wᵢ ≥ 0

df = df.resample('1min').last().ffill()

async def on_tick(self, tick):

train, test = split(df, at='2023-01-01')

def sharpe(r): return r.mean() / r.std() * np.sqrt(252)

cov = returns.ewm(halflife=20).cov()

θ̂ = argmin ∑ (yᵢ − f(xᵢ; θ))²

dS = μS dt + σS dW

Lotus Capital · Quantitative Research & Automation

We build, test, and evolve trading strategies.

Lotus Capital brings together quantitative research, software engineering, and automation to develop systematic approaches to financial markets.

Explore Our Work

01What we do

Research that becomes systems.

01
Strategy Research
Investigate market behaviour, form testable hypotheses, and explore quantitative approaches to trading.
02
Strategy Development
Translate research ideas into systematic implementations that can be evaluated, compared, and improved.
03
Automation & Engineering
Build the software and automation that makes trading workflows repeatable and reliable.
04
Testing & Improvement
Evaluate strategies, examine results honestly, investigate weaknesses, and find room for refinement.

02The technical environment

Bring your expertise. Build on our infrastructure.

We provide a technology environment designed to support systematic trading work. Our objective is to let talented people focus on the problems they are best equipped to solve: researching ideas, developing strategies, improving implementations, and building automation.

You bring

hypotheses · models · code
statistical rigour · domain insight

We provide

trading platform · APIs
technical infrastructure

Own platform: Lotus Capital operates its own trading platform and technical infrastructure.
APIs: APIs are part of the technical environment that contributors build on.
Focus: Spend your time on your area of expertise rather than rebuilding foundations from zero.
Collaboration: An environment intended to connect research, development, testing, and engineering.

Access to systems, data, and capital depends on the role and is subject to internal authorisation.

03Who we are looking for

Different expertise. Shared ambition.

We are interested in people who think rigorously, build carefully, and want to apply their expertise to quantitative research and systematic trading.

Quantitative research
Algorithmic trading development
Python and software engineering
Automation
Data engineering and analysis
Mathematics, statistics, and applied research

04Internships

An entry point into quantitative research.

We welcome applications from motivated students and early-career candidates interested in quantitative finance, programming, mathematics, data, and automation. Tell us what you have been learning, what you have built, and the problems you would like to explore.

All applications are reviewed. Submitting an application does not guarantee an internship.

05Apply

Let's build something meaningful.

Tell us about your background, your interests, and how you could contribute to quantitative research and trading technology at Lotus Capital.

Full nameRequired

Email addressRequired

Application typeRequired

Primary area of interestRequired

Technical background or relevant experienceRequired

Languages, tools, research, projects — whatever best shows how you work.

Why do you want to contribute to Lotus Capital?Required

LinkedIn URLOptional

GitHub or portfolio URLOptional

Privacy notice. The information you submit is used only to review your application and to contact you about relevant opportunities at Lotus Capital. It is stored securely and is not shared publicly. Please do not include passwords, account credentials, financial details, or identification numbers.

I have read the privacy notice and agree that my information may be used to review my application.

We build, test, and evolve trading strategies.

Research that becomes systems.

Strategy Research

Strategy Development

Automation & Engineering

Testing & Improvement

Bring your expertise. Build on our infrastructure.

Different expertise. Shared ambition.

An entry point into quantitative research.

Let's build something meaningful.