Proofpoint Interview Experience | Senior Software Engineer (Go)
- Posted
- 21 Oct 2026
Summary
I completed four interview rounds—technical screening, low‑level design, project deep‑dive with coding, and behavioral—focused on Go concurrency, rate‑limiting design, and data‑structure transformations.
How it went
Round 1: Technical Screening — Rate Limiter Design
Problem: Design and implement a rate limiter using the Fixed Window Counter algorithm in Go.
Topics covered:
- Fixed window rate-limiting logic.
- Tracking request counts within a time window.
- Handling window expiration and resetting counters.
- Writing clean, maintainable Go code.
- Discussing concurrency and thread safety.
The focus was on implementing the core logic and explaining the design choices.
Round 2: Low-Level Design — Sports Management Service
Problem: Design a sports management service supporting player management and player-count tracking.
Requirements included:
- CRUD operations for players.
- Maintaining and retrieving player counts.
- Designing appropriate data structures and service methods.
- Handling concurrent access to shared data.
Go concepts that received particular attention:
- Goroutines and channels.
- Mutexes and synchronization.
- Thread-safe operations.
- Concurrency handling and race conditions.
Be prepared to explain when to use channels versus mutexes and how to keep shared state consistent under concurrent access.
Round 3: Project Deep Dive + Coding
This round had two parts.
1. Project deep dive
Discussed previous projects, technical decisions, implementation details, challenges, and trade‑offs. Be ready to explain your contributions clearly and answer follow‑up questions about your design choices.
2. Coding problem: Transform a flat map into a nested map
Given a map with dotted keys, convert it into a nested map structure.
Input:
{
"a.bbb.c": {"data": 1},
"a.bbb.d": {"data": 5},
"a.cc": {"data": 2},
"a.cd.d.e": {"data": 3, "foo": 4},
"b.a": {"data": 7}
}
Expected output:
{
"a": {
"bbb": {
"c": {"data": 1},
"d": {"data": 5}
},
"cc": {"data": 2},
"cd": {
"d": {
"e": {"data": 3, "foo": 4}
}
}
},
"b": {
"a": {"data": 7}
}
}
The task was to implement a transformation that splits dotted keys and builds the corresponding nested map structure while preserving the original values.
The supplied implementation notes emphasized processing keys in sorted order so that prefixes are handled before their descendants and the resulting structure is merged correctly.
Round 4: Behavioral + Go Experience
This round focused on:
- Behavioral questions based on previous work experience.
- Project ownership and technical challenges.
- Experience with Go and its concurrency model.
- Design decisions, trade‑offs, and problem‑solving approaches.
Be prepared to discuss real examples from your projects and explain your hands‑on experience with Go rather than relying only on theoretical knowledge.
Overall Takeaways
- Prepare LLD problems in Go, especially CRUD‑based services and concurrent systems.
- Practise goroutines, channels, mutexes, and race‑condition handling.
- Understand rate‑limiting algorithms, including the fixed‑window approach.
- Practise transforming nested data structures and maps.
- Be thorough with project deep dives and behavioral questions.
- Focus on code readability, correctness, maintainability, and explaining your decisions.
This is based on my interview experience, so the questions and emphasis may vary for other candidates. Hope this helps others preparing for Proofpoint!
Good luck to everyone interviewing!
Questions asked (3)
- 01
Rate Limiter using Fixed Window Counter (Go)
System Design
Design and implement a rate limiter using the Fixed Window Counter algorithm in Go. The solution should track request counts within a configurable time window, handle window expiration and counter reset, and be thread‑safe for concurrent access. Discuss the core logic, data structures, and any concurrency primitives used.
- 02
Sports Management Service – Low‑Level Design
System Design
Design a sports management service that supports CRUD operations for players and maintains a real‑time player count. The service must handle concurrent access, provide methods to add, update, delete, and retrieve players, and expose an API to get the current player count. Consider appropriate data structures, synchronization mechanisms, and how to keep shared state consistent.
- 03
Transform Flat Map with Dotted Keys to Nested Map
Data Structures & Algorithms
Given a map whose keys are dotted strings (e.g.,
"a.bbb.c") and whose values are arbitrary JSON objects, convert it into a nested map where each dot represents a deeper level. The conversion must preserve the original leaf values and correctly merge shared prefixes.Input Example:
{ "a.bbb.c": {"data": 1}, "a.bbb.d": {"data": 5}, "a.cc": {"data": 2}, "a.cd.d.e": {"data": 3, "foo": 4}, "b.a": {"data": 7} }Expected Output:
{ "a": { "bbb": { "c": {"data": 1}, "d": {"data": 5} }, "cc": {"data": 2}, "cd": { "d": { "e": {"data": 3, "foo": 4} } } }, "b": { "a": {"data": 7} } }The solution should process keys in sorted order to ensure parent prefixes are created before their children.
How they prepared
I prepared by practicing low‑level design problems in Go, focusing on CRUD services and concurrent systems, studying rate‑limiting techniques (especially the fixed‑window algorithm), and implementing exercises that transform flat maps with dotted keys into nested structures. I also reviewed Go concurrency primitives such as goroutines, channels, and mutexes to articulate trade‑offs during the interview.