Introduction

Three years ago, if I told myself I would reject two offers from a top bank in Singapore, I would not have believed it. Those roles offered exciting technology and a huge boost in brand prestige.

Rejecting them was a hard decision, but it boiled down to a simple truth. Some environments prioritize high-level observation, whereas I wanted a place that offered direct, hands-on experience. I chose growth over prestige. I wanted an environment that would push my technical boundaries.

The Reality of the High Autonomy

Many fast-paced tech environments champion extreme autonomy, expecting engineers to solve complex problems without handholding.

The reality I faced brought steep challenges. With minimal formal onboarding, I was thrown straight into the deep end with competing priorities and open-ended requirements.

Adapting to that fast-paced environment taught me lessons that go far beyond writing code.

Crucial Lessons in Communication

In a high-velocity environment, communication is your lifeline.

• Overcommunicate: It is always better to overcommunicate than to undercommunicate. Do not just say you have a problem. Explain that you faced a problem and detail the active steps you are taking to fix it. Do not wait too long out of fear or embarrassment.
• Communicate with empathy: High-pressure situations require thoughtful phrasing. Under tight deadlines, brief or casual comments can easily be misconstrued. Being intentional and constructive with your tone keeps the team aligned and focused on solving the problem.
• Align on scope early: Address potential bottlenecks and ambiguities before diving into execution. Ask detailed questions upfront to clarify requirements, and be transparent about bandwidth, technical dependencies, and realistic timelines.

Navigating Ambiguity

When working with minimal initial documentation, my instinct was to tackle problems completely solo. I quickly realized that strategic collaboration is far more efficient. This is what I learned afterwards, and what you should do instead.

• Seek out the best: Be daring and do the things that are hard. But do not do them alone. Find likeminded individuals willing to help. Find the person who is performing the best at their job, follow their lead, and ask them directly for guidance.
• Time-box the struggle: Try to solve a problem for a fixed period of 30 minutes. If you are still stuck after that, drop your ego and ask for help.
• Quality first: It is always better to deliver high quality first, then focus on speed. Speed is useless if it creates defects.

Maintain Sustainable Pace & Wellbeing

Technical excellence is a marathon, not a sprint. Recognize when high-pressure pacing becomes unsustainable and prioritize work-life integration. Knowing how to maintain your momentum without burning out is essential for a long-term engineering career.

Technical Resources to Kickstart Your Journey

Operating at a full SWE1 level meant taking immediate ownership of code tracing, production bug fixes, and incident response. To match the steep learning curve, I continuously upskilled on core backend stack components. Here is a summary of the key concepts that were essential to mastering this environment:

Here is a summary of the core concepts to help you survive a similar backend environment:

Nest.js

• main.ts bootstraps the app via NestFactory.
• app.module.ts is a module that packages other modules.
• Modules are containers that organize a part of the application. They contain controllers, services, repositories, entities, and DTOs.
• Controllers: Handle HTTP routing and requests.
• Services: Execute business logic.
• Repositories: Data access layer via ORM.
• Entities: Class that maps directly to the database table.
• DTOs: Define data shape for validation during transit.
• Principles: Heavy Dependency Injection for modularity and easier unit testing (SOLID).

N8N

• Use drag and drop to design your own automation flow.
• Behind the hood, it is Node.js. You can write custom code for more complex tasks.
• Create AI agents and link up with AI models. Define system and user prompts.
• Use tools to call APIs for Jira, Gitlab, Slack, Google, and Email.
• Use databases to persist knowledge via Vector, Postgres, or Redis.

Kafka

• Brokers host Topics, which are split into Partitions (append only logs).
• Producer: Serializes and sends data.
• Consumer: Deserializes and "polls" data. It sends Heartbeats to signal liveness.
• Unlike a queue, messages persist after being read using Offset tracking.

Database Optimization

• Seq Scan: Reading every row, which is slow.
• Index Scan: Using a B-Tree or map to jump directly to data, which is fast.
• Analysis: Use EXPLAIN ANALYZE to identify bottlenecks.

Datadog

• Use dashboards for a high level overview of services like endpoints, logs, metrics, traces, and overall health.
• Metrics: Tells you "Is it broken?" by checking CPU, RAM, and Latency.
• Traces: Tells you "Where is it slow?" by following the path of a single request across services.
• Logs: Tells you "Why is it broken?" by showing error messages and timestamps.