Achievements
Development of a web application for mapping life trajectories
Achievement summary
This summary provides the essential reading points. It does not replace the complete case study: scroll down to review the detailed context, steps, limitations, and critical review.
- Context
- During a five-month internship at the Grenoble Computer Science Laboratory, a sociological research need had to be turned into an interactive life-trajectories application.
- Challenge
- Make complex life narratives recordable and visualizable without losing dates, uncertainty, or the scientific consistency of the data.
- My role
- I designed and developed the first interactive system, from the questionnaire and data through the D3.js visualization, with the researcher's scientific guidance.
- Key decision
- Build a custom D3.js visualization and explicit temporal-conflict handling instead of simplifying ambiguous cases.
- Result
- CAP2vie makes life paths understandable through a custom visualization that preserves their chronological evolution and relationships between dimensions.
- Evidence
- Application screenshots and the linked internship experience make the prototype and its research context visible.View the detailed evidence
Visual proof
Screenshots and demos from real projects.
Media 1 of 6
User profile selection
Entry screen allowing the user to choose between interviewer and respondent roles.
01
Presentation
During a five-month internship at the Grenoble Computer Science Laboratory, I worked on CAP2vie, a prototype for sociological interviews. The interviewer enters reported events, and the participant can see where they sit along their life trajectory. The visualization gives them a shared way to review the account and correct dates during the interview.
Replacing data collection performed mainly on paper. Before the application, information was gathered through paper forms. This medium supports an interview, but becomes difficult to maintain when questions evolve and complex to analyze when several trajectories must be compared. Answers have to be reread, transcribed, and restructured before they can feed a visualization or comparison. The project therefore sought to digitize data collection during the interview and produce an organized representation progressively, without waiting for a complete manual re-entry after every survey.
Two complementary roles within the same interview. The interviewer was the sociologist responsible for asking questions according to their methodology and recording relevant information. The participant answered questions about their history. This separation was represented in the application through interfaces suited to both roles. The interviewer needed controls for conducting and structuring data collection, while the participant needed to understand the representation of their path without accessing survey-management functions.
Three student developers worked under the guidance of a researcher. I handled the D3.js visualization, part of the backend and screen synchronization. My colleagues focused primarily on the questionnaire and database.
02
Objectives, context and stakes
Starting from a questionnaire defined by the researchers. The prototype used a set of questions provided for the experiment. Sociologists were not yet expected to create, modify, or version their own questionnaires within the application. A dynamic questionnaire would have required an administration interface, management of multiple field types, and rules allowing a form to evolve without making previous answers incompatible. This feature was relevant to a future release, but was not needed to verify the central principle during the five months.
Representing dimensions separately and simultaneously. The visualization had to provide several readings. Dimensions such as education, work, family, relationships, or places of residence could be viewed separately to keep each path readable. They could also be overlaid or brought together in a shared view to observe simultaneous events. This dual reading addressed the sociological need — understand every area of life and then look for temporal relationships between several areas without confusing them.
The scope changed when researchers asked for a second screen so the participant could follow the trajectory live. The interviewer needed to keep entering responses if that screen disconnected. The internship was meant to produce a demonstrable prototype with enough documentation for another developer to take over.
03
Risks and mitigation measures
The main risk was a chart that looked convincing but misrepresented the interview. Treating an estimate as an exact date or automatically connecting intervals could change the interpretation of the account. Ambiguous cases needed to be reviewed with researchers and tested using interview examples.
A form experience capable of disrupting the interview. A slow, rigid, or difficult-to-correct form could distract the interviewer and break the conversation's rhythm. It could also encourage incomplete entry simply because a field was misunderstood. Demonstrations and iterations with sociologists tested the interface against their actual questioning practice. Control went beyond checking that a button worked — the tool had to remain compatible with their interview methods.
The second screen brought a risk that recorded responses and the displayed chart could fall out of sync. The prototype was designed for controlled local use. Because life stories can contain sensitive information, field deployment would have required additional safeguards, including more complete access controls and anonymization.
Access features still limited by scope. Complete management of multiple surveys, multiple people, and their permissions was considered, but was not the purpose of the prototype. Local operation reduced exposure during demonstrations without replacing a genuine access policy. A deployed release should authenticate users, separate studies, and limit each researcher to authorized data. Postponing these features was acceptable for a proof of concept, but incompatible with large-scale real data collection.
04
The steps — what I did
Modeling data with PostgreSQL and Prisma. PostgreSQL was selected as a relational database because the information formed linked entities and the technology was familiar to the team. A relational database organizes data in tables associated through identifiers. Prisma acted as the ORM, or object-relational mapping tool — it allowed us to describe models in code, create the database structure, and manipulate records without writing every SQL query manually. This combination simplified prototype setup and understanding of the model.
Building a single form organized with a stepper. The questionnaire occupied one page, but was divided into successive stages through a stepper. A stepper is a component that guides a user through several sections while indicating progress. Each stage could correspond to a trajectory dimension. This organization avoided displaying every question at once and allowed the interviewer to focus on one area before moving to the next.
Adapting questions to previous answers. The questionnaire was dynamic. For the professional trajectory, it could ask whether the person had held a job, then display questions about that job and its period only when the answer justified them. At the end of this entry, it asked whether another job should be added and repeated the sequence when necessary. This conditional logic allowed a variable number of events to be collected without imposing irrelevant fields on a person whose path was different.
Building periods from exact or estimated dates. Start and end dates were the central information sent to the chart. When an exact date was unknown, we applied a rule consistent with the survey method. A missing start date could reuse the end of the previous event in the same dimension. an unknown end date could extend to the beginning of the next event. This estimate produced usable continuity while leaving the interviewer and participant able to correct the boundaries when their conversation provided more precise information.
Building the chart with D3.js primitives. We used SVG elements, axes, and time scales. SVG is a vector graphics format integrated into web pages. Its shapes remain sharp when resized. A time scale converts a date into a horizontal or vertical position within the available space, while an axis provides markers for reading that position. D3.js prevented us from reimplementing these basic calculations while leaving us free to compose a representation unavailable in a ready-made charting library.
Sending chart edits back to the form. The first architecture ran from the form to the chart. Direct editing required a path in the opposite direction. A period edited on screen had to update the response and recalculate the trajectory. I separated the trajectory state from its SVG rendering so both interfaces stayed consistent. I spent most time reworking this link because a change visible only on the chart would have left a different answer in the questionnaire.
For the second screen, I added Socket.io rooms associated with interview sessions. The interviewer could start a session and the other screen received trajectory updates. Rejoining after disconnection remained a manual step in the prototype.
Synchronizing only the state required by the second screen. The interviewer retained the form and their own chart. The participant received only the data required to display their trajectory. When an answer or date changed the chart, the corresponding state was sent to the room and applied on the secondary screen. Limiting exchanged data to this need simplified the flow and prevented the participant interface from exposing controls reserved for conducting the interview.
05
The stakeholders — interactions
The supervising researcher translated scientific requirements into scenarios and worked with the other researchers to decide how the chart should represent events. We divided development work among the interns and reviewed code before merging. Weekly reviews helped us surface differences between our interpretation and what the interview process needed.
Code reviews before every merge. We reviewed changes before integrating them into the shared branch. A code review involves examining another developer's proposal to identify an error, check readability, and ensure it respects expected behavior. I performed most of these reviews and usually decided whether changes could join the main branch. This responsibility made me a de facto technical checkpoint even though I had not been assigned an official lead-developer role.
Validation performed through simulation. During the internship, we did not participate in actual interviews with survey participants. Usage tests were conducted as simulations with researchers. This method allowed the interview flow, questions, and chart reactions to be verified without immediately involving real data. It was nevertheless a limitation — an actual research interview may reveal hesitation, unexpected accounts, and field constraints that a simulation between people already familiar with the tool reproduces imperfectly.
The handover lasted two weeks. We demonstrated the full workflow, documented installation and explained which areas needed more work. The incoming developer installed the application, giving us a first check of the handover instructions.
06
The results
The prototype supported completing the questionnaire, displaying five dimensions in two views and correcting a response in either the form or the chart. Synchronization was demonstrated on two screens. The screenshots illustrate these workflows. Researchers could review an end-to-end version in simulated interviews.
Approximately twenty main questions supplemented by repeatable sequences. The questionnaire contained more than twenty core questions. This number did not represent the maximum interview length because some groups could loop according to answers. The professional trajectory, for example, asked for a job description and then offered the option to add another. A person who had held several positions therefore generated multiple occurrences of the same sequence. The prototype could adapt collection to the richness of a path instead of imposing a fixed number of events.
Known defects remaining in synchronization. Delivery was not bug-free. Graphical data synchronization was not yet perfect, and some sequences could produce a delay or inconsistent state between screens. This finding remained compatible with the proof-of-concept objective, but prevented real-time communication from being considered ready for unsupervised field use. The result is therefore a demonstrated interconnection accompanied by a clearly identified need for stabilization.
The checks available at handover. All tests written by handover passed. They covered selected behavior in the form, chart and synchronization. We still needed more systematic checks for a late second screen joining and for reconnection after an edit during a drop. These scenarios would have helped verify that both screens returned to the same state.
Visible evidence already included in the portfolio. The page already presents screenshots of profile selection, local interfaces, and the survey-creation journey. These elements show that the prototype existed and illustrate its general behavior without exposing actual participant data. Detailed text also explains technical choices and personal contribution. I limit evidence to what can be published — some project elements, code, and later developments remain confidential.
07
After the project
The first handover priority was to make synchronization reliable when a screen joined late or reconnected. Proposed follow-up work covered access rights, anonymization and data export before the tool could be assessed under real research conditions.
Automatic anonymization planned for continuation. The application was ultimately intended to handle anonymization of collected data itself. This feature would separate identity information from answers used for analysis through a reproducible procedure. It still had to be designed with researchers — removing only a first and last name does not guarantee that a highly distinctive trajectory cannot be recognized. A future release therefore needed to define the affected fields, when transformation occurred, and who could access information before anonymization.
CSV as the planned export format. CSV was the planned format for extracting data. A CSV file organizes information as rows and columns separated by a character, allowing it to be opened in a spreadsheet or imported into analysis software. Export had to preserve dimensions, dates, and events in an understandable structure. The exact destination platform was not yet known, requiring a format documented well enough to remain usable by several tools.
The handover and prototype installation were outcomes of my internship. I have no evidence of deployment after I left. We passed on known issues and possible improvements with the code to support the team’s next decisions.
08
My critical review
I integrated the first chart before working through enough ambiguous date ranges. The connection between the questionnaire and D3.js became the part I rewrote most. I would have saved time by showing the researchers a complex trajectory earlier and turning their decisions into repeatable scenarios.
Making uncertainty visible. Reusing one event’s end date as the unknown start of the next can create artificial continuity. The convention helped build a timeline during the interview but could suggest a level of precision the account did not provide. In a follow-up version, I would retain where each date came from in the data model and signal that in the chart. This would help the interviewer and participant see which periods need review or correction.
Sufficient weekly meetings but end-to-end feedback obtained too late. One demonstration per week was appropriate for the internship pace. What I would have liked earlier was not necessarily more meetings, but feedback as soon as the form was connected to chart data. This first complete chain was the point at which researchers could observe the real effect of their answers. Showing it earlier would have revealed bridge weaknesses before several features depended on its initial architecture.
I would keep direct editing in the chart because it supports discussion during an interview. I would first validate a small end-to-end workflow and then add cases for estimated dates, edits in both directions and screen reconnection. That would reveal the limitations before expanding the demonstration.


